TTFQuery 2.0.1a1__py3-none-any.whl

ttfquery/__init__.py

@@ -0,0 +1,2 @@
+"""Fonttools package for querying and sorting system fonts"""
+__version__ = "2.0.1a1"

ttfquery/_scriptregistry.py

@@ -0,0 +1,16 @@
+"""The singleton "registry" object (an instance of :class:`ttfquery.ttffiles.Registry`
+is the only member of note).  This registry with be created in a file 
+in the user's $HOME directory ``.font.cache`` if the $HOME environment variable 
+is defined.  Otherwise will be created in the ttfquery source code directory 
+(which is obviously not a very good solution).
+
+.. note::
+
+    This module is basically here for legacy applications that used
+    the singleton registry instance. Use scriptregistry.get_registry()
+    in new code.
+"""
+from ttfquery import scriptregistry
+
+_getRegistry = scriptregistry.get_registry
+registry = scriptregistry.get_registry()

ttfquery/describe.py

@@ -0,0 +1,332 @@
+"""Extract meta-data from a font-file to describe the font"""
+from fontTools import ttLib
+import sys
+
+try:
+    unicode, long
+except NameError:
+    unicode = str
+    long = int
+try:
+    from OpenGLContext.debug.logs import text_log
+except ImportError:
+    text_log = None
+
+
+def openFont(filename):
+    """Get a new font object"""
+    if isinstance(filename, (bytes, unicode)):
+        filename = open(filename, "rb")
+    return ttLib.TTFont(filename)
+
+
+FONT_SPECIFIER_NAME_ID = 4
+FONT_SPECIFIER_FAMILY_ID = 1
+
+
+def shortName(font):
+    """Get the short name from the font's names table"""
+    name = ""
+    family = ""
+    for record in font["name"].names:
+        if record.nameID == FONT_SPECIFIER_NAME_ID and not name:
+            if b"\000" in record.string:
+                name = unicode(record.string, "utf-16-be").encode("utf-8")
+            else:
+                name = record.string
+        elif record.nameID == FONT_SPECIFIER_FAMILY_ID and not family:
+            if b"\000" in record.string:
+                family = unicode(record.string, "utf-16-be").encode("utf-8")
+            else:
+                family = record.string
+        if name and family:
+            break
+    return name, family
+
+
+FAMILY_NAMES = {
+    0: ("ANY", {}),
+    1: (
+        "SERIF-OLD",
+        {
+            0: "ANY",
+            1: "ROUNDED-LEGIBILITY",
+            2: "GARALDE",
+            3: "VENETIAN",
+            4: "VENETIAN-MODIFIED",
+            5: "DUTCH-MODERN",
+            6: "DUTCH-TRADITIONAL",
+            7: "CONTEMPORARY",
+            8: "CALLIGRAPHIC",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    2: (
+        "SERIF-TRANSITIONAL",
+        {
+            0: "ANY",
+            1: "DIRECT-LINE",
+            2: "SCRIPT",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    3: (
+        "SERIF",
+        {
+            0: "ANY",
+            1: "ITALIAN",
+            2: "SCRIPT",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    4: (
+        "SERIF-CLARENDON",
+        {
+            0: "ANY",
+            1: "CLARENDON",
+            2: "MODERN",
+            3: "TRADITIONAL",
+            4: "NEWSPAPER",
+            5: "STUB-SERIF",
+            6: "MONOTYPE",
+            7: "TYPEWRITER",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    5: (
+        "SERIF-SLAB",
+        {
+            0: "ANY",
+            1: "MONOTONE",
+            2: "HUMANIST",
+            3: "GEOMETRIC",
+            4: "SWISS",
+            5: "TYPEWRITER",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    7: (
+        "SERIF-FREEFORM",
+        {
+            0: "ANY",
+            1: "MODERN",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    8: (
+        "SANS",
+        {
+            0: "ANY",
+            1: "GOTHIC-NEO-GROTESQUE-IBM",
+            2: "HUMANIST",
+            3: "ROUND-GEOMETRIC-LOW-X",
+            4: "ROUND-GEOMETRIC-HIGH-X",
+            5: "GOTHIC-NEO-GROTESQUE",
+            6: "GOTHIC-NEO-GROTESQUE-MODIFIED",
+            9: "GOTHIC-TYPEWRITER",
+            10: "MATRIX",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    9: (
+        "ORNAMENTAL",
+        {
+            0: "ANY",
+            1: "ENGRAVER",
+            2: "BLACK-LETTER",
+            3: "DECORATIVE",
+            4: "THREE-DIMENSIONAL",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    10: (
+        "SCRIPT",
+        {
+            0: "ANY",
+            1: "UNCIAL",
+            2: "BRUSH-JOINED",
+            3: "FORMAL-JOINED",
+            4: "MONOTONE-JOINED",
+            5: "CALLIGRAPHIC",
+            6: "BRUSH-UNJOINED",
+            7: "FORMAL-UNJOINED",
+            8: "MONOTONE-UNJOINED",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    12: (
+        "SYMBOL",
+        {
+            0: "ANY",
+            3: "MIXED-SERIF",
+            6: "OLDSTYLE-SERIF",
+            7: "NEO-GROTESQUE-SANS",
+            15: "MISCELLANEOUS",
+        },
+    ),
+}
+
+WEIGHT_NAMES = {
+    "thin": 100,
+    "extralight": 200,
+    "ultralight": 200,
+    "light": 300,
+    "normal": 400,
+    "regular": 400,
+    "plain": 400,
+    "medium": 500,
+    "semibold": 600,
+    "demibold": 600,
+    "bold": 700,
+    "extrabold": 800,
+    "ultrabold": 800,
+    "black": 900,
+    "heavy": 900,
+}
+WEIGHT_NUMBERS = {}
+for key, value in WEIGHT_NAMES.items():
+    WEIGHT_NUMBERS.setdefault(value, []).append(key)
+
+
+def weightNumber(name):
+    """Convert a string-name to a weight number compatible with this module"""
+    if isinstance(name, (bytes, unicode)):
+        name = name.lower()
+        name = name.replace("-", "").replace(" ", "")
+        if name and name[-1] == "+":
+            name = name[:-1]
+            adjust = 50
+        elif name and name[-1] == "-":
+            name = name[:-1]
+            adjust = -50
+        else:
+            adjust = 0
+        return WEIGHT_NAMES[name] + adjust
+    else:
+        return int(name) or 400  # for cases where number isn't properly specified
+
+
+def weightName(number):
+    """Convert integer number to a human-readable weight-name"""
+    number = int(number) or 400
+    if number in WEIGHT_NUMBERS:
+        return WEIGHT_NUMBERS[number]
+    name = "thin-"
+    for x in range(100, 1000, 100):
+        if number >= x:
+            name = WEIGHT_NUMBERS[x][0] + "+"
+    return name
+
+
+def family(font):
+    """Get the family (and sub-family) for a font"""
+    HIBYTE = 65280
+    LOBYTE = 255
+    familyID = (font["OS/2"].sFamilyClass & HIBYTE) >> 8
+    subFamilyID = font["OS/2"].sFamilyClass & LOBYTE
+    return familyNames(familyID, subFamilyID)
+
+
+def familyNames(familyID, subFamilyID=0):
+    """Convert family integers to human-readable names"""
+    familyName, subFamilies = FAMILY_NAMES.get(familyID, ("RESERVED", None))
+    if familyName == "RESERVED":
+        if text_log:
+            text_log.warn("Font has invalid (reserved) familyID: %s", familyID)
+    if subFamilies:
+        subFamily = subFamilies.get(subFamilyID, "RESERVED")
+    else:
+        subFamily = "ANY"
+    return (familyName, subFamily)
+
+
+def modifiers(font):
+    """Get weight and italic modifiers for a font
+
+    weight is taken from the OS/2 usWeightClass field
+    italic is taken from either OS/2 fsSelection or
+    head macStyle, if either indicates italics we
+    report italics
+    """
+    return (
+        # weight as an integer
+        font["OS/2"].usWeightClass,
+        (font["OS/2"].fsSelection & 1 or font["head"].macStyle & 2),  # italic
+    )
+
+
+def guessEncoding(font, given=None):
+    """Attempt to guess/retrieve an encoding from the font itself
+
+    Basically this will try to get the given encoding
+    (unless it is None).
+
+    If given is a single integer or a single-item tuple,
+    we will attempt scan looking for any table matching
+    given as the platform ID and returning the first sub
+    table.
+
+    If given is a two-value tuple, we will require
+    explicit matching, and raise errors if the encoding
+    cannot be retrieved.
+
+    if given is None, we will return the first encoding
+    in the font.
+
+    XXX This needs some work, particularly for non-win32
+        platforms, where there is no preference embodied
+        for the native encoding.
+    """
+    if isinstance(given, tuple) and given:
+        if len(given) == 2:
+            if __debug__:
+                if text_log:
+                    text_log.info(
+                        """Checking for explicitly required encoding %r""", given
+                    )
+            if not font["cmap"].getcmap(*given):
+                raise ValueError(
+                    """The specified font encoding %r does not appear to be available within the font %r. Available encodings: %s"""
+                    % (
+                        given,
+                        shortName(font),
+                        [
+                            (table.platformID, table.platEncID)
+                            for table in font["cmap"].tables
+                        ],
+                    )
+                )
+            return given
+        elif len(given) > 2:
+            raise TypeError(
+                """Encoding must be None, a two-tuple, or an integer, got %r"""
+                % (given,)
+            )
+        else:
+            # treat as a single integer, regardless of number of integer's
+            given = given[0]
+    if isinstance(given, (int, long)):
+        for table in font["cmap"].tables:
+            if table.platformID == given:
+                return (table.platformID, table.platEncID)
+        raise ValueError(
+            """Could not find encoding with specified platformID==%s within the font %r. Available encodings: %s"""
+            % (
+                given,
+                shortName(font),
+                [(table.platformID, table.platEncID) for table in font["cmap"].tables],
+            )
+        )
+    if sys.platform == "win32":
+        prefered = (3, 1)
+        # should have prefered values for Linux and Mac as well...
+        for table in font["cmap"].tables:
+            if (table.platformID, table.platEncID) == prefered:
+                return prefered
+    # just retrieve the first table's values
+    for table in font["cmap"].tables:
+        return (table.platformID, table.platEncID)
+    raise ValueError(
+        """There are no encoding tables within the font %r, likely a corrupt font-file"""
+        % (shortName(font),)
+    )

ttfquery/findsystem.py

@@ -0,0 +1,142 @@
+"""Find system fonts (only works on Linux and Win32 at the moment)"""
+from __future__ import print_function
+try:
+    unicode
+except NameError:
+    unicode = str
+import sys, os, glob, re
+
+def win32FontDirectory( ):
+    """Get User-specific font directory on Win32"""
+    try:
+        import _winreg
+    except ImportError:
+        return os.path.join(os.environ['WINDIR'], 'Fonts')
+    else:
+        k = _winreg.OpenKey(
+            _winreg.HKEY_CURRENT_USER,
+            r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+        )
+        try:
+            # should check that k is valid? How?
+            return _winreg.QueryValueEx( k, "Fonts" )[0]
+        finally:
+            _winreg.CloseKey( k )
+
+def win32InstalledFonts( fontDirectory = None ):
+    """Get list of explicitly *installed* font names
+    
+    IFF there is no registry entry for installed fonts,
+    likely due to a too-new windows install, then we'll
+    just return all .ttf files in fontDirectory
+    """
+    import _winreg
+    if fontDirectory is None:
+        fontDirectory = win32FontDirectory()
+    k = None
+    items = {}
+    for keyName in (
+        r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts",
+        r"SOFTWARE\Microsoft\Windows\CurrentVersion\Fonts",
+    ):
+        try:
+            k = _winreg.OpenKey(
+                _winreg.HKEY_LOCAL_MACHINE,
+                keyName
+            )
+        except OSError as err:
+            pass
+    if not k:
+        # couldn't open either WinNT or Win98 key???
+        return glob.glob( os.path.join(fontDirectory, '*.ttf'))
+    try:
+        # should check that k is valid? How?
+        for index in range( _winreg.QueryInfoKey(k)[1]):
+            key,value,_ = _winreg.EnumValue( k, index )
+            if not os.path.dirname( value ):
+                value = os.path.join( fontDirectory, value )
+            value = os.path.abspath( value ).lower()
+            if value[-4:] == '.ttf':
+                items[ value ] = 1
+        return items.keys()
+    finally:
+        _winreg.CloseKey( k )
+    
+
+def linuxFontDirectories( ):
+    """Get system font directories on Linux/Unix
+    
+    Uses /usr/sbin/chkfontpath to get the list
+    of system-font directories, note that many
+    of these will *not* be truetype font directories.
+
+    If /usr/sbin/chkfontpath isn't available, uses
+    returns a set of common Linux/Unix paths
+    """
+    executable = '/usr/sbin/chkfontpath'
+    if os.path.isfile( executable ):
+        data = os.popen( executable ).readlines()
+        match = re.compile( r'\d+: (.+)')
+        set = []
+        for line in data:
+            result = match.match( line )
+            if result:
+                set.append(result.group(1))
+        return set
+    else:
+        directories = [
+            # what seems to be the standard installation point
+            "/usr/X11R6/lib/X11/fonts/TTF/",
+            # common application, not really useful
+            "/usr/lib/openoffice/share/fonts/truetype/",
+            # documented as a good place to install new fonts...
+            "/usr/share/fonts",
+            "/usr/local/share/fonts",
+            # seems to be where fonts are installed for an individual user?
+            "~/.fonts",
+            # okay, now the OS X variants...
+            "~/Library/Fonts/",
+            "/Library/Fonts/",
+            "/Network/Library/Fonts/",
+            "/System/Library/Fonts/",
+            "System Folder:Fonts:",
+        ]
+        
+        set = []
+        for directory in directories:
+            directory = directory = os.path.expanduser( os.path.expandvars(directory))
+            for (dirname,_,_) in os.walk(directory):
+                if os.path.exists(dirname) and dirname not in set:
+                    set.append(dirname)
+        return set
+
+def findFonts(paths = None):
+    """Find fonts in paths, or the system paths if not given
+
+    XXX Doesn't current support OS-X system paths
+    """
+    files = {}
+    if paths is None:
+        if sys.platform == 'win32':
+            fontDirectory = win32FontDirectory()
+            paths = [
+                fontDirectory,
+            ]
+            # now get all installed fonts directly...
+            for f in win32InstalledFonts(fontDirectory):
+                # yes, it's inefficient, the interface
+                # for win32InstalledFonts really should be
+                # using sets, not lists
+                files[f] = 1
+        else:
+            paths = linuxFontDirectories()
+    elif isinstance( paths, (bytes, unicode)):
+        paths = [paths]
+    for path in paths:
+        for file in glob.glob( os.path.join(path, '*.ttf')):
+            files[os.path.abspath(file)] = 1
+    return list(files.keys())
+
+if __name__ == "__main__":
+    print('linux font directories', linuxFontDirectories())
+    print('font names', findFonts())

ttfquery/glyph.py

@@ -0,0 +1,194 @@
+"""Representation of a single glyph including contour extraction"""
+from ttfquery import glyphquery
+import numpy
+
+class Glyph( object):
+    """Object encapsulating metadata regarding a particular glyph"""
+    def __init__(self, glyphName ):
+        """Initialize the glyph object
+
+        glyphName -- font's glyphName for this glyph, see
+            glyphquery.glyphName() for extracting the
+            appropriate name from character and encoding.
+        """
+        self.glyphName = glyphName
+    def compile( self, font, steps = 3 ):
+        """Compile the glyph to a set of poly-line outlines"""
+        self.contours = self.calculateContours( font )
+        self.outlines = [
+            decomposeOutline(contour,steps)
+            for contour in self.contours
+        ]
+        self.width = glyphquery.width( font, self.glyphName )
+        self.height = glyphquery.lineHeight( font )
+    
+    def calculateContours( self, font ):
+        """Given a character, determine contours to draw
+
+        returns a list of contours, with each contour
+        being a list of ((x,y),flag) elements.  There may
+        be only a single contour.
+        """
+        glyf = font['glyf']
+        charglyf = glyf[self.glyphName]
+        return self._calculateContours( charglyf, glyf, font )
+    def _calculateContours( self, charglyf, glyf, font ):
+        """Create expanded contour data-set from TTF charglyph entry
+
+        This is called recursively for composite glyphs, so
+        I suppose a badly-formed TTF file could cause an infinite
+        loop.
+
+        charglyph -- glyf table's entry for the target character
+        glyf -- the glyf table (used for recursive calls)
+        """
+        charglyf.expand( font ) # XXX is this extraneous?
+        contours = []
+        if charglyf.numberOfContours == 0:
+            # does not display at all, for instance, space
+            pass
+        elif charglyf.isComposite():
+            # composed out of other items...
+            for component in charglyf.components:
+                subContours = self._calculateContours(
+                    glyf[component.glyphName],
+                    glyf,
+                    font
+                )
+                dx,dy = component.getComponentInfo()[1][-2:]
+                # XXX we're ignoring the scaling/shearing/etceteras transformation
+                # matrix which is given by component.getComponentInfo()[1][:4]
+                subContours = [
+                    [((x+dx,y+dy),f) for ((x,y),f) in subContour]
+                    for subContour in subContours
+                ]
+                contours.extend(
+                    subContours
+                )
+        else:
+            flags = charglyf.flags
+            coordinates = charglyf.coordinates
+            # We need to convert from the "end point" representation
+            # to a distinct contour representation, requires slicing
+            # each contour out of the list and then closing it
+            last = 0
+            for e in charglyf.endPtsOfContours:
+                set = zip(
+                    list(coordinates[last:e+1])+list(coordinates[last:last+1]),
+                    list(flags[last:e+1])+list(flags[last:last+1])
+                )
+                contours.append( list(set) )
+                last = e+1
+            if coordinates[last:]:
+                contours.append( list(zip(
+                    list(coordinates[last:])+list(coordinates[last:last+1]),
+                    list(flags[last:])+list(flags[last:])
+                ) ))
+        return contours
+        
+def decomposeOutline( contour, steps=3 ):
+    """Decompose a single TrueType contour to a line-loop
+
+    In essence, this is the "interpretation" of the font
+    as geometric primitives.  I only support line and
+    quadratic (conic) segments, which should support most
+    TrueType fonts as far as I know.
+
+    The process consists of first scanning for any multi-
+    off-curve control-point runs.  For each pair of such
+    control points, we insert a new on-curve control point.
+
+    Once we have the "expanded" control point array we
+    scan through looking for each segment which includes
+    an off-curve control point.  These should only be
+    bracketed by on-curve control points.  For each
+    found segment, we call our integrateQuadratic method
+    to produce a set of points interpolating between the
+    end points as affected by the middle control point.
+
+    All other control points merely generate a single
+    line-segment between the endpoints.
+    """
+    # contours must be closed, but they can start with
+    # (and even end with) items not on the contour...
+    # so if we do, we need to create a new point to serve
+    # as the midway...
+    if len(contour)<3:
+        return ()
+    set = contour[:]
+    def on( record ):
+        """Is this record on the contour?
+        
+        record = ((Ax,Ay),Af)
+        """
+        return record[-1] == 1
+
+    def merge( first, second):
+        """Merge two off-point records into an on-point record"""
+        ((Ax,Ay),Af) = first 
+        ((Bx,By),Bf) = second
+        return (((Ax+Bx)/2.0),((Ay+By))/2.0),1
+    # create an expanded set so that all adjacent
+    # off-curve items have an on-curve item added
+    # in between them
+    last = contour[-1]
+    expanded = []
+    for item in set:
+        if (not on(item)) and (not on(last)):
+            expanded.append( merge(last, item))
+        expanded.append( item )
+        last = item
+    result = []
+    last = expanded[-1]
+    while expanded:
+        assert on(expanded[0]), "Expanded outline doesn't have proper format! Should always have either [on, off, on] or [on, on] as the first items in the outline"
+        if len(expanded)>1:
+            if on(expanded[1]):
+                # line segment from 0 to 1
+                result.append( expanded[0][0] )
+                #result.append( expanded[1][0] )
+                del expanded[:1]
+            else:
+                if len(expanded) == 2:                          #KH
+                    assert on(expanded[0]), """Expanded outline finishes off-curve""" #KH
+                    result.append( expanded[1][0] )         #KH
+                    del expanded[:1] 
+                    break
+                assert on(expanded[2]), "Expanded outline doesn't have proper format!"
+                points = integrateQuadratic( expanded[:3], steps = steps )
+                result.extend( points )
+                del expanded[:2]
+        else:
+            assert on(expanded[0]), """Expanded outline finishes off-curve"""
+            result.append( expanded[0][0] )
+            del expanded[:1]
+    result.append( result[-1] )
+    return result
+def integrateQuadratic( points, steps=3 ):
+    """Get points on curve for quadratic w/ end points A and C
+
+    Basis Equations are taken from here:
+        http://www.truetype.demon.co.uk/ttoutln.htm
+
+    This is a very crude approach to the integration,
+    everything is coded directly in Python, with no
+    attempts to speed up the process.
+
+    XXX Should eventually provide adaptive steps so that
+        the angle between the elements can determine how
+        many steps are used.
+    """
+    step = 1.0/steps
+    ((Ax,Ay),_),((Bx,By),_),((Cx,Cy),_) = points
+    result = [(Ax,Ay)]
+    ### XXX This is dangerous, in certain cases floating point error
+    ## can wind up creating a new point at 1.0-(some tiny number) if step
+    ## is sliaghtly less than precisely 1.0/steps
+    for t in numpy.arange( step, 1.0, step ):
+        invT = 1.0-t
+        px = (invT*invT * Ax) + (2*t*invT*Bx) + (t*t*Cx)
+        py = (invT*invT * Ay) + (2*t*invT*By) + (t*t*Cy)
+        result.append( (px,py) )
+    # the end-point will be added by the next segment...
+    #result.append( (Cx,Cy) )
+    return result