#Copyright ReportLab Europe Ltd. 2000-2012

#see license.txt for license details

__version__ = '$Id$'

__doc__="""TrueType font support

This defines classes to represent TrueType fonts.  They know how to calculate

their own width and how to write themselves into PDF files.  They support

subsetting and embedding and can represent all 16-bit Unicode characters.

Note on dynamic fonts

---------------------

Usually a Font in ReportLab corresponds to a fixed set of PDF objects (Font,

FontDescriptor, Encoding).  But with dynamic font subsetting a single TTFont

will result in a number of Font/FontDescriptor/Encoding object sets, and the

contents of those will depend on the actual characters used for printing.

To support dynamic font subsetting a concept of "dynamic font" was introduced.

Dynamic Fonts have a _dynamicFont attribute set to 1.

Dynamic fonts have the following additional functions::

    def splitString(self, text, doc):

        '''Splits text into a number of chunks, each of which belongs to a

        single subset.  Returns a list of tuples (subset, string).  Use

        subset numbers with getSubsetInternalName.  Doc is used to identify

        a document so that different documents may have different dynamically

        constructed subsets.'''

    def getSubsetInternalName(self, subset, doc):

        '''Returns the name of a PDF Font object corresponding to a given

        subset of this dynamic font.  Use this function instead of

        PDFDocument.getInternalFontName.'''

You must never call PDFDocument.getInternalFontName for dynamic fonts.

If you have a traditional static font, mapping to PDF text output operators

is simple::

   '%s 14 Tf (%s) Tj' % (getInternalFontName(psfontname), text)

If you have a dynamic font, use this instead::

   for subset, chunk in font.splitString(text, doc):

       '%s 14 Tf (%s) Tj' % (font.getSubsetInternalName(subset, doc), chunk)

(Tf is a font setting operator and Tj is a text ouput operator.  You should

also escape invalid characters in Tj argument, see TextObject._formatText.

Oh, and that 14 up there is font size.)

Canvas and TextObject have special support for dynamic fonts.

"""

import string

from struct import pack, unpack, error as structError

from reportlab.pdfbase import pdfmetrics, pdfdoc

from reportlab import rl_config

class TTFError(pdfdoc.PDFError):

    "TrueType font exception"

    pass

def SUBSETN(n,table=string.maketrans('0123456789','ABCDEFGHIJ')):

    return ('%6.6d'%n).translate(table)

#

# Helpers

#

from codecs import utf_8_encode, utf_8_decode, latin_1_decode

parse_utf8=lambda x, decode=utf_8_decode: list(map(ord,decode(x)[0]))

parse_latin1 = lambda x, decode=latin_1_decode: list(map(ord,decode(x)[0]))

def latin1_to_utf8(text):

    "helper to convert when needed from latin input"

    return utf_8_encode(latin_1_decode(text)[0])[0]

def makeToUnicodeCMap(fontname, subset):

    """Creates a ToUnicode CMap for a given subset.  See Adobe

    _PDF_Reference (ISBN 0-201-75839-3) for more information."""

    cmap = [

        "/CIDInit /ProcSet findresource begin",

        "12 dict begin",

        "begincmap",

        "/CIDSystemInfo",

        "<< /Registry (%s)" % fontname,

        "/Ordering (%s)" % fontname,

        "/Supplement 0",

        ">> def",

        "/CMapName /%s def" % fontname,

        "/CMapType 2 def",

        "1 begincodespacerange",

        "<00> <%02X>" % (len(subset) - 1),

        "endcodespacerange",

        "%d beginbfchar" % len(subset)

        ] + ["<%02X> <%04X>" % (i,v) for i,v in enumerate(subset)] + [

        "endbfchar",

        "endcmap",

        "CMapName currentdict /CMap defineresource pop",

        "end",

        "end"

        ]

    return string.join(cmap, "\n")

def splice(stream, offset, value):

    """Splices the given value into stream at the given offset and

    returns the resulting stream (the original is unchanged)"""

    return stream[:offset] + value + stream[offset + len(value):]

def _set_ushort(stream, offset, value):

    """Writes the given unsigned short value into stream at the given

    offset and returns the resulting stream (the original is unchanged)"""

    return splice(stream, offset, pack(">H", value))

try:

    import _rl_accel

except ImportError:

    try:

        from reportlab.lib import _rl_accel

    except ImportError:

        _rl_accel = None

try:

    hex32 = _rl_accel.hex32

except:

    def hex32(i):

        return '0X%8.8X' % (int(i)&0xFFFFFFFF)

try:

    add32 = _rl_accel.add32L

    calcChecksum = _rl_accel.calcChecksumL

except:

    def add32(x, y):

        "Calculate (x + y) modulo 2**32"

        return (x+y) & 0xFFFFFFFF

    def calcChecksum(data):

        """Calculates TTF-style checksums"""

        if len(data)&3: data = data + (4-(len(data)&3))*"\0"

        return sum(unpack(">%dl" % (len(data)>>2), data)) & 0xFFFFFFFF

del _rl_accel

#

# TrueType font handling

#

GF_ARG_1_AND_2_ARE_WORDS        = 1 << 0

GF_ARGS_ARE_XY_VALUES           = 1 << 1

GF_ROUND_XY_TO_GRID             = 1 << 2

GF_WE_HAVE_A_SCALE              = 1 << 3

GF_RESERVED                     = 1 << 4

GF_MORE_COMPONENTS              = 1 << 5

GF_WE_HAVE_AN_X_AND_Y_SCALE     = 1 << 6

GF_WE_HAVE_A_TWO_BY_TWO         = 1 << 7

GF_WE_HAVE_INSTRUCTIONS         = 1 << 8

GF_USE_MY_METRICS               = 1 << 9

GF_OVERLAP_COMPOUND             = 1 << 10

GF_SCALED_COMPONENT_OFFSET      = 1 << 11

GF_UNSCALED_COMPONENT_OFFSET    = 1 << 12

def TTFOpenFile(fn):

    '''Opens a TTF file possibly after searching TTFSearchPath

    returns (filename,file)

    '''

    from reportlab.lib.utils import rl_isfile, open_for_read

    try:

        f = open_for_read(fn,'rb')

        return fn, f

    except IOError:

        import os

        if not os.path.isabs(fn):

            for D in rl_config.TTFSearchPath:

                tfn = os.path.join(D,fn)

                if rl_isfile(tfn):

                    f = open_for_read(tfn,'rb')

                    return tfn, f

        raise TTFError('Can\'t open file "%s"' % fn)

class TTFontParser:

    "Basic TTF file parser"

    ttfVersions = (0x00010000,0x74727565,0x74746366)

    ttcVersions = (0x00010000,0x00020000)

    fileKind='TTF'

    def __init__(self, file, validate=0,subfontIndex=0):

        """Loads and parses a TrueType font file.  file can be a filename or a

        file object.  If validate is set to a false values, skips checksum

        validation.  This can save time, especially if the font is large.

        """

        self.validate = validate

        self.readFile(file)

        isCollection = self.readHeader()

        if isCollection:

            self.readTTCHeader()

            self.getSubfont(subfontIndex)

        else:

            if self.validate: self.checksumFile()

            self.readTableDirectory()

            self.subfontNameX = ''

    def readTTCHeader(self):

        self.ttcVersion = self.read_ulong()

        self.fileKind = 'TTC'

        self.ttfVersions = self.ttfVersions[:-1]

        if self.ttcVersion not in self.ttcVersions: 

            raise TTFError('"%s" is not a %s file: can\'t read version 0x%8.8x' %(self.filename,self.fileKind,self.ttcVersion))

        self.numSubfonts = self.read_ulong()

        self.subfontOffsets = []

        a = self.subfontOffsets.append

        for i in range(self.numSubfonts):

            a(self.read_ulong())

    def getSubfont(self,subfontIndex):

        if self.fileKind!='TTC':

            raise TTFError('"%s" is not a TTC file: use this method' % (self.filename,self.fileKind))

        try:

            pos = self.subfontOffsets[subfontIndex]

        except IndexError:

            raise TTFError('TTC file "%s": bad subfontIndex %s not in [0,%d]' % (self.filename,subfontIndex,self.numSubfonts-1))

        self.seek(pos)

        self.readHeader()

        self.readTableDirectory()

        self.subfontNameX = '-'+str(subfontIndex)

    def readTableDirectory(self):

        try:

            self.numTables = self.read_ushort()

            self.searchRange = self.read_ushort()

            self.entrySelector = self.read_ushort()

            self.rangeShift = self.read_ushort()

            # Read table directory

            self.table = {}

            self.tables = []

            for n in range(self.numTables):

                record = {}

                record['tag'] = self.read_tag()

                record['checksum'] = self.read_ulong()

                record['offset'] = self.read_ulong()

                record['length'] = self.read_ulong()

                self.tables.append(record)

                self.table[record['tag']] = record

        except:

            raise TTFError('Corrupt %s file "%s" cannot read Table Directory' % (self.fileKind, self.filename))

        if self.validate: self.checksumTables()

    def readHeader(self):

        '''read the sfnt header at the current position'''

        try:

            self.version = version = self.read_ulong()

        except:

            raise TTFError('"%s" is not a %s file: can\'t read version' %(self.filename,self.fileKind))

        if version==0x4F54544F:

            raise TTFError('%s file "%s": postscript outlines are not supported'%(self.fileKind,self.filename))

        if version not in self.ttfVersions:

            raise TTFError('Not a TrueType font: version=0x%8.8X' % version)

        return version==self.ttfVersions[-1]

    def readFile(self,f):

        if hasattr(f,'read'):

            self.filename = '(ttf)'

        else:

            self.filename, f = TTFOpenFile(f)

        self._ttf_data = f.read()

        self._pos = 0

    def checksumTables(self):

        # Check the checksums for all tables

        for t in self.tables:

            table = self.get_chunk(t['offset'], t['length'])

            checksum = calcChecksum(table)

            if t['tag'] == 'head':

                adjustment = unpack('>l', table[8:8+4])[0]

                checksum = add32(checksum, -adjustment)

            xchecksum = t['checksum']

            if xchecksum != checksum:

                raise TTFError('TTF file "%s": invalid checksum %s table: %s (expected %s)' % (self.filename,hex32(checksum),t['tag'],hex32(xchecksum)))

    def checksumFile(self):

        # Check the checksums for the whole file

        checksum = calcChecksum(self._ttf_data)

        if 0xB1B0AFBA!=checksum:

            raise TTFError('TTF file "%s": invalid checksum %s (expected 0xB1B0AFBA) len: %d &3: %d' % (self.filename,hex32(checksum),len(self._ttf_data),(len(self._ttf_data)&3)))

    def get_table_pos(self, tag):

        "Returns the offset and size of a given TTF table."

        offset = self.table[tag]['offset']

        length = self.table[tag]['length']

        return (offset, length)

    def seek(self, pos):

        "Moves read pointer to a given offset in file."

        self._pos = pos

    def skip(self, delta):

        "Skip the given number of bytes."

        self._pos = self._pos + delta

    def seek_table(self, tag, offset_in_table = 0):

        """Moves read pointer to the given offset within a given table and

        returns absolute offset of that position in the file."""

        self._pos = self.get_table_pos(tag)[0] + offset_in_table

        return self._pos

    def read_tag(self):

        "Read a 4-character tag"

        self._pos += 4

        return self._ttf_data[self._pos - 4:self._pos]

    def read_ushort(self):

        "Reads an unsigned short"

        self._pos += 2

        return unpack('>H',self._ttf_data[self._pos-2:self._pos])[0]

    def read_ulong(self):

        "Reads an unsigned long"

        self._pos += 4

        return unpack('>L',self._ttf_data[self._pos - 4:self._pos])[0]

    def read_short(self):

        "Reads a signed short"

        self._pos += 2

        try:

            return unpack('>h',self._ttf_data[self._pos-2:self._pos])[0]

        except structError as error:

            raise TTFError(error)

    def get_ushort(self, pos):

        "Return an unsigned short at given position"

        return unpack('>H',self._ttf_data[pos:pos+2])[0]

    def get_ulong(self, pos):

        "Return an unsigned long at given position"

        return unpack('>L',self._ttf_data[pos:pos+4])[0]

    def get_chunk(self, pos, length):

        "Return a chunk of raw data at given position"

        return self._ttf_data[pos:pos+length]

    def get_table(self, tag):

        "Return the given TTF table"

        pos, length = self.get_table_pos(tag)

        return self._ttf_data[pos:pos+length]

class TTFontMaker:

    "Basic TTF file generator"

    def __init__(self):

        "Initializes the generator."

        self.tables = {}

    def add(self, tag, data):

        "Adds a table to the TTF file."

        if tag == 'head':

            data = splice(data, 8, '\0\0\0\0')

        self.tables[tag] = data

    def makeStream(self):

        "Finishes the generation and returns the TTF file as a string"

        write = stm.write

        numTables = len(self.tables)

        searchRange = 1

        entrySelector = 0

        while searchRange * 2 <= numTables:

            searchRange = searchRange * 2

            entrySelector = entrySelector + 1

        searchRange = searchRange * 16

        rangeShift = numTables * 16 - searchRange

        # Header

        write(pack(">lHHHH", 0x00010000, numTables, searchRange,

                                 entrySelector, rangeShift))

        # Table directory

        tables = list(self.tables.items())

        tables.sort()     # XXX is this the correct order?

        offset = 12 + numTables * 16

        for tag, data in tables:

            if tag == 'head':

                head_start = offset

            checksum = calcChecksum(data)

            write(tag)

            write(pack(">LLL", checksum, offset, len(data)))

            paddedLength = (len(data)+3)&~3

            offset = offset + paddedLength

        # Table data

        for tag, data in tables:

            data += "\0\0\0"

            write(data[:len(data)&~3])

        checksum = calcChecksum(stm.getvalue())

        checksum = add32(0xB1B0AFBA, -checksum)

        stm.seek(head_start + 8)

        write(pack('>L', checksum))

        return stm.getvalue()

class TTFontFile(TTFontParser):

    "TTF file parser and generator"

    def __init__(self, file, charInfo=1, validate=0,subfontIndex=0):

        """Loads and parses a TrueType font file.

        file can be a filename or a file object.  If validate is set to a false

        values, skips checksum validation.  This can save time, especially if

        the font is large.  See TTFontFile.extractInfo for more information.

        """

        TTFontParser.__init__(self, file, validate=validate,subfontIndex=subfontIndex)

        self.extractInfo(charInfo)

    def extractInfo(self, charInfo=1):

        """

        Extract typographic information from the loaded font file.

        The following attributes will be set::

            name         PostScript font name

            flags        Font flags

            ascent       Typographic ascender in 1/1000ths of a point

            descent      Typographic descender in 1/1000ths of a point

            capHeight    Cap height in 1/1000ths of a point (0 if not available)

            bbox         Glyph bounding box [l,t,r,b] in 1/1000ths of a point

            _bbox        Glyph bounding box [l,t,r,b] in unitsPerEm

            unitsPerEm   Glyph units per em

            italicAngle  Italic angle in degrees ccw

            stemV        stem weight in 1/1000ths of a point (approximate)

        If charInfo is true, the following will also be set::

            defaultWidth   default glyph width in 1/1000ths of a point

            charWidths     dictionary of character widths for every supported UCS character

                           code

        This will only work if the font has a Unicode cmap (platform 3,

        encoding 1, format 4 or platform 0 any encoding format 4).  Setting

        charInfo to false avoids this requirement

        """

        # name - Naming table

        name_offset = self.seek_table("name")

        format = self.read_ushort()

        if format != 0:

            raise TTFError("Unknown name table format (%d)" % format)

        numRecords = self.read_ushort()

        string_data_offset = name_offset + self.read_ushort()

        names = {1:None,2:None,3:None,4:None,6:None}

        K = list(names.keys())

        nameCount = len(names)

        for i in range(numRecords):

            platformId = self.read_ushort()

            encodingId = self.read_ushort()

            languageId = self.read_ushort()

            nameId = self.read_ushort()

            length = self.read_ushort()

            offset = self.read_ushort()

            if nameId not in K: continue

            N = None

            if platformId == 3 and encodingId == 1 and languageId == 0x409: # Microsoft, Unicode, US English, PS Name

                opos = self._pos

                try:

                    self.seek(string_data_offset + offset)

                    if length % 2 != 0:

                        raise TTFError("PostScript name is UTF-16BE string of odd length")

                    length /= 2

                    N = []

                    A = N.append

                    while length > 0:

                        char = self.read_ushort()

                        A(chr(char))

                        length -= 1

                    N = ''.join(N)

                finally:

                    self._pos = opos

            elif platformId == 1 and encodingId == 0 and languageId == 0: # Macintosh, Roman, English, PS Name

                # According to OpenType spec, if PS name exists, it must exist

                # both in MS Unicode and Macintosh Roman formats.  Apparently,

                # you can find live TTF fonts which only have Macintosh format.

                N = self.get_chunk(string_data_offset + offset, length)

            if N and names[nameId]==None:

                names[nameId] = N

                nameCount -= 1

                if nameCount==0: break

        if names[6] is not None:

            psName = names[6].replace(" ", "-")  #Dinu Gherman's fix for font names with spaces

        elif names[4] is not None:

            psName = names[4].replace(" ", "-")

        # Fine, one last try before we bail.

        elif names[1] is not None:

            psName = names[1].replace(" ", "-")

        else:

            psName = None

        # Don't just assume, check for None since some shoddy fonts cause crashes here...

        if not psName:

            raise TTFError("Could not find PostScript font name")

        for c in psName:

            oc = ord(c)

            if oc>126 or c in ' [](){}<>/%':