# rfi.rb -- general use classes
#--
# Last Change: Tue May 16 19:21:51 2006
#++

require 'rfil/font/glyph'

module RFIL # :nodoc: 

  # = RFI
  # Everything that does not fit somewhere else gets included in the
  # wrapper class RFI.
  
  # This class contains methods and other classes that are pretty much
  # useless of their own or are accessed in different classes.
  
  class RFI # :nodoc:
    
    # Super class for plugins. Just subclass this Plugin, set the name
    # when calling Plugin#new and implement run_plugin.
    class Plugin
      # Name of the plugin. A Symbol or a String.
      attr_reader :name

      attr_reader :filetypes
      
      # Create a new plugin. _name_ is the name of the plugin (it must
      # be a Symbol or a String). _filetypes_ is a list of symbols, of
      # what files the plugin is capable of writing.
      def initialize(name,*filetypes)
        @name=name
        @filetypes=filetypes
      end
      
      # Return an Array of files that should be written on the user's
      # harddrive. The Hash entries are
      # [<tt>:type</tt>] Type of the file (<tt>:fd</tt>, <tt>:typescript</tt> etc.)
      # [<tt>:filename</tt>] The filename (without a path) of the file.
      # [<tt>:contents</tt>] The contents of the file.
      def run_plugin
        #dummy
      end
    end
    
    # Some instructions to remove kerning information from digits and
    # other things. -> sort this out 
    STDLIGKERN = ["space l =: lslash",
                  "space L =: Lslash", "question quoteleft =: questiondown",
                  "exclam quoteleft =: exclamdown", "hyphen hyphen =: endash",
                  "endash hyphen =: emdash", "quoteleft quoteleft =: quotedblleft",
                  "quoteright quoteright =: quotedblright", "space {} *", "* {} space",
                  "zero {} *", "* {} zero",
                  "one {} *",  "* {} one",
                  "two {} *",  "* {} two", 
                  "three {} *","* {} three",
                  "four {} *", "* {} four",
                  "five {} *", "* {} five",
                  "six {} *",  "* {} six",
                  "seven {} *", "* {} seven",
                  "eight {} *", "* {} eight",
                  "nine {} *", "* {} nine",
                  "comma comma =: quotedblbase",
                  "less less =: guillemotleft",
                  "greater greater =: guillemotright"]
    
    # Metric information about a glyph. Does not contain the glyph
    # (outlines) itself.
    class Char < Font::Glyph
      
      # fontnumber is used in Font class
      attr_accessor :fontnumber

      # If not nil, _mapto_ is the glyphname that should be used instead
      # of the current one.
      attr_accessor :mapto
      
      # Sets the extension factor. This is used by calculations of _wx_,
      # _llx_ and _urx_.
      attr_accessor :efactor

      # Sets the slant factor. This is used by calculations of _wx_,
      # _llx_ and _urx_.
      attr_accessor :slant

      def wx       # :nodoc:
        transform(@wx,0)
      end
      def wx=(obj) # :nodoc:
        @wx=obj
      end
      # Lower left x position of glyph.
      def llx            # :nodoc:
        transform(@b[0],b[1])
      end                  

      # Upper right x position of glyph.
      def urx            # :nodoc:
        transform(@b[2],ury)
      end
      
      private

      def transform (x,y)
        (@efactor * x + @slant * y)
      end

    end # class Char

    
    # Represent the different ligatures possible in tfm.
    class LIG
      
      @@encligops = ["=:", "|=:", "|=:>", "=:|", "=:|>", "|=:|", "|=:|>", "|=:|>>"]
      @@vpligops = ["LIG", "/LIG", "/LIG>", "LIG/", "LIG/>", "/LIG/",
                    "/LIG/>", "/LIG/>>"]
      @@symligops = [:lig, :"lig/",  :"/lig",  :"/lig/", :"lig/>", :"/lig>", :"/lig/>", :"/lig/>>"]

      # First glyph of a two glyph sequence before it is turned into a
      # ligature.
      attr_accessor :left

      # Second glyph of a two glyph sequence before it is turned into a
      # ligature.
      attr_accessor :right

      # The ligature that gets inserterd instead of the left and right glyph.
      attr_accessor :result
      
      # <tt>[0,   1,    2,     3,    4,     5,     6,      7 ]</tt>
      #
      # <tt>[=: , |=: , |=:> , =:| , =:|>,  |=:|,  |=:|>,  |=:|>> ]</tt>
      #
      # <tt>[LIG, /LIG, /LIG>, LIG/, LIG/>, /LIG/, /LIG/>, /LIG/>>]</tt>
      attr_accessor :type

      
      
      # call-seq:
      #   new
      #   new(left,[right,[result,[type]]])
      #   new(hash)
      #   new(otherlig)
      # 
      # When called with left, right, result or type parameters, take
      # these settings for the LIG object. When called with a hash as an
      # argument, the keys should look like: :left,:right,:result,:type.
      # When called with an existing LIG object, the values are taken
      # from the old object.
      def initialize(left=nil,right=nil,result=nil,type=nil)
        case left
        when Hash
          [:left,:right,:result,:type].each { |sym|
            if left.has_key?(sym)
              self.send((sym.to_s+"=").to_sym,left[sym])
            end
          }
        when LIG
          [:left,:right,:result,:type].each { |sym|
            self.send((sym.to_s+"=").to_sym,left.send(sym))
          }
          # warning!!!!! LIG accepts a String as well as Fixnum as
          # parameters, this might have side effects!?
        when Fixnum,nil,String
          @left=left
          @right=right
          @result=result
          @type=type
        else
          raise "unknown argument for new() in LIG: #{left}"
        end
        # test!
        #unless @type.instance_of?(Fixnum)
        #  raise "type must be a fixnum"
        #end
      end
      def ==(lig)
        @left=lig.left and
          @right=lig.right and
          @result=lig.result and
          @type=lig.type
      end

      def to_pl(encoding)
        encoding.glyph_index[@right].sort.collect { |rightslot|
          left=encoding.glyph_index[@left].min
          # right=encoding.glyph_index[@right].min
          result=encoding.glyph_index[@result].min
          type=@@vpligops[@type]
          LIG.new(:left=>left, :right=>rightslot, :result=>result, :type=>type)
        }
      end
      # Return an array that is suitable for tfm
      def to_tfminstr(encoding)
        encoding.glyph_index[@right].sort.collect { |rightslot|
          left=encoding.glyph_index[@left].min
          # right=encoding.glyph_index[@right].min
          result=encoding.glyph_index[@result].min
          type=@@symligops[@type]
          [type,rightslot,result]
        }
      end
      def inspect
        "[#{@type.to_s.upcase} #@left + #@right => #@result]"
      end
    end
    
    require 'forwardable'

    # Stores information about kerning and ligature information. Allows
    # deep copy of ligature and kerning information. Obsolete. Don't use.
    class LigKern
      extend Forwardable
      # Optional parameter initializes the new LigKern object.
      def initialize(h={})
        @h=h
      end
      
      def_delegators(:@h, :each, :[], :[]=,:each_key,:has_key?)
      
      def initialize_copy(obj) # :nodoc:
        tmp={}
        if obj[:lig]
          tmp[:lig]=Array.new
          obj[:lig].each { |elt|
            tmp[:lig].push(elt.dup)
          }
        end
        if obj[:krn]
          tmp[:krn]=Array.new
          obj[:krn].each { |elt|
            tmp[:krn].push(elt.dup)
          }
        end
        if obj[:alias]
          tmp[:alias]=obj[:alias].dup
        end
        @h=tmp
      end
      # Compare this object to another object of the same class.
      def ==(obj)
        return false unless obj.respond_to?(:each)
        # the krn needs to be compared one by one, because they are floats
        if obj.has_key?(:krn)
          obj[:krn].each { |destchar,value|
            return false unless @h[:krn].assoc(destchar)
            return false if (value - @h[:krn].assoc(destchar)[1]).abs > 0.01
          }
        end
        obj.each { |key,value|
          next if key==:krn
          return false unless @h[key]==value
        }
        true
      end
    end

    
    # The Glyphlist is a actually a Hash with some special methods
    # attached.
    class Glyphlist < Hash
      @@encligops = ["=:", "|=:", "|=:>", "=:|", "=:|>", "|=:|", "|=:|>", "|=:|>>"]
      @@vpligops = ["LIG", "/LIG", "/LIG>", "LIG/", "LIG/>", "/LIG/",
                    "/LIG/>", "/LIG/>>"]

      # Return an array with name of glyphs that are represented by the
      # symbol _glyphlist_.
      # These symbols are defined: :lowercase, :uppercase, :digits
      def get_glyphlist(glyphlist)
        ret=[]
        unless glyphlist.instance_of? Symbol
          raise ArgumentError, "glyphlist must be a symbol" 
        end
        case glyphlist
        when :lowercase
          update_uc_lc_list
          
          self.each { |glyphname,char|
            if char.uc != nil
              ret.push glyphname
            end
          }
        when :uppercase
          update_uc_lc_list
          
          self.each { |glyphname,char|
            if char.lc != nil
              ret.push glyphname
            end
          }
        when :digits
          ret=%w(one two three four five six seven eight nine zero)
        end
        ret
      end

      # instructions.each must yield string objects (i.e. an array of
      # strings, an IO object, a single string, ...). Instruction is like:
      # "space l =: lslash" or "two {} *"
      def apply_ligkern_instructions (instructions)
        instructions.each { |instr|
          s = instr.split(' ')
          
          if @@encligops.member?(s[2]) # one of =:, |=: |=:> ...
            if self[s[0]]
              self[s[0]].lig_data[s[1]]=LIG.new(s[0],s[1],s[3],@@encligops.index(s[2]))
            else
              # puts "glyphlist#apply_ligkern_instructions: char not found: #{s[0]}"
            end
          elsif s[1] == "{}"
            remove_kern(s[0],s[2])
          end
        }
      end
      # _left_ and _right_ must be either a glyphname or a '*'
      # (asterisk) which acts like a wildcard. So ('one','*') would
      # remove all kerns of glyph 'one' where 'one' is the left glyph in
      # a kerning pair.
      def remove_kern(left,right)
        raise ArgumentError, "Only one operand may be '*'" if left=='*' and right=='*'
        if right == "*"
          self[left].kern_data={} if self[left]
        elsif left == "*"
          if self[right]
            self.each { |name,chardata|
              chardata.kern_data.delete(right)
            }
          end
        else
          if self[right] and self[left]
            self[left].kern_data.delete(right)
          end
        end
      end
      
      # Update all glyph entries to see what the uppercase or the
      # lowercase variants are. Warning!! Tcaron <-> tquoteright in
      # non-unicode fonts.
      def update_uc_lc_list
        # we need this list only when faking small caps (which will, of
        # course, never happen!)
        
        # make a list of all uppercase and lowercase glyphs. Be aware of
        # ae<->AE, oe<->OE, germandbls<-->SS, dotlessi->I, dotlessj->J
        # do the
        #      @upper_lower={}
        # @lower_upper={}
        self.each_key {|glyphname|
          thischar=self[glyphname]
          if glyphname =~ /^[a-z]/
            if glyphname =~ /^(a|o)e$/ and self[glyphname.upcase]
              thischar.uc = glyphname.upcase
            elsif glyphname =~ /^dotless(i|j)$/
              thischar.uc = glyphname[-1].chr.upcase
            elsif self[glyphname.capitalize]
              thischar.uc = glyphname.capitalize
            end
          else
            if glyphname =~ /^(A|O)e$/ and self[glyphname.dowcase]
              thischar.lc = glyphname.downcase
            elsif self[glyphname.downcase]
              thischar.lc = glyphname.downcase
            end
          end
        }
        if self['germandbls']
          self['germandbls'].uc='S'
        end
      end

      # Modify the charmetrics and the kerning/ligatures so that the
      # lowercase chars are made from scaling uppercase chars.
      def fake_caps (factor)
        update_uc_lc_list
        # we need to do the following
        # 1. adapt kerning pairs
        # 2. change font metrics (wd)
        # 3. remove ligatures from sc
        @fake_caps=true
        @capheight=factor
        self.each { |glyphname,char|
          if char.is_lowercase?
            # remove ligatures from sc
            char.lig_data={}
            char.kern_data={}
            char.mapto=char.capitalize
            self[char.uc].kern_data.each { |destglyph,kerndata|
              unless self[destglyph].is_lowercase?
                char.kern_data[destglyph.downcase]=[kerndata[0] * factor,0]
              end
            }
            char.b = self[char.capitalize].b.clone
            char.wx = self[char.capitalize].wx * @capheight
            char.lly *= @capheight
            char.urx *= @capheight
            char.ury *= @capheight
          else # char is something like Aring, semicolon, ...
            # if destchar is uppercase letter (A, Aring, ...)
            # 1. delete all kerns to lowercase letters (not e.g. semicolon)
            # 2. duplicate all uc kerns, multiply by factor and insert this
            #    as lc kern
            char.kern_data.delete_if { |destglyph,kerndata|
              self[destglyph].is_lowercase?
            }

            new_kern_data={}
            char.kern_data.each { |destglyph,kerndata|
              if self[destglyph].is_uppercase?
                new_kern_data[self[destglyph].downcase]=[kerndata[0]*factor,kerndata[1]]
              end
              new_kern_data[destglyph]=kerndata
            }
            char.kern_data=new_kern_data
          end
          # 2.  
        }
        if self['germandbls']
          s=self['S']
          d=self['germandbls']

          d.b = s.b.dup
          d.wx = s.wx * 2 * @capheight
          d.urx += s.wx
          
          
          d.kern_data={}
          s.kern_data.each { |destglyph,kerndata|
            unless self[destglyph].is_lowercase?
              # we are looking at non-lowercase chars. These might be
              # ones that are uppercase or are 'something else', e.g.
              # hyphen...
              # since we only replace the lc variants, keep the uc and
              # others intact.
              if self[destglyph].is_uppercase? 
                d.kern_data[self[destglyph].downcase]=[kerndata[0] * @capheight,0]

              else
                d.kern_data[destglyph]=[kerndata[0] * @capheight,0]
                
              end
            end
          }
          
          d.pcc_data=[['S',0,0],['S',s.wx,0]]
          d.lly *= @capheight
          d.urx *= @capheight
          
        end
      end # fake_caps

      def fix_height(xheight)
        # this is what afm2tfm does. I am not sure if it is clever.
        self.each { |name,data|
          
          # xheight <= 50  -> @chars[char].ury
          # char.size > 1  -> @chars[char].ury
          # char+accentname (ntilde, udieresis,...) exists?
          #   then calculate else @chars[char].ury
          # calculate := ntilde.ury - tilde.ury + xheight
          # same as texheight in afm2tfm source
          unless name.size>1 or xheight < 50
            %w(acute tilde caron dieresis).each {|accent|
              naccent=name + accent
              next unless self[naccent]
              data.ury = self[naccent].ury - self[accent].ury + xheight
              break
            }
          end
        }
      end # fix_height
    end # class Glyphlist
  end # class RFI
end