TTFQuery 2.0.1a1__py3-none-any.whl

ttfquery/glyphquery.py

@@ -0,0 +1,90 @@
+"""Glyph-specific queries on font-files"""
+from ttfquery import describe
+try:
+    from OpenGLContext.debug.logs import text_log
+except ImportError:
+    text_log = None
+
+def hasGlyph( font, char, encoding=None ):
+    """Check to see if font appears to have explicit glyph for char"""
+    glyfName = explicitGlyph( font, char, encoding )
+    if glyfName is None:
+        return False
+    return True
+def explicitGlyph( font, char, encoding=None ):
+    """Return glyphName or None if there is not explicit glyph for char"""
+    cmap = font['cmap']
+    if encoding is None:
+        encoding = describe.guessEncoding( font )
+    table = cmap.getcmap( *encoding )
+    glyfName = table.cmap.get( ord(char))
+    return glyfName
+
+def glyphName( font, char, encoding=None, warnOnFailure=1 ):
+    """Retrieve the glyph name for the given character
+
+    XXX
+        Not sure what the effect of the Unicode mapping
+        will be given the use of ord...
+    """
+    glyfName = explicitGlyph( font, char, encoding )
+    if glyfName is None:
+        encoding = describe.guessEncoding( font )       #KH
+        cmap = font['cmap']                             #KH
+        table = cmap.getcmap( *encoding )               #KH
+        glyfName = table.cmap.get( -1)
+        if glyfName is None:
+            glyfName = font['glyf'].glyphOrder[0]
+            if text_log and warnOnFailure:
+                text_log.warn(
+                    """Unable to find glyph name for %r, in %r using first glyph in table (%r)""",
+                    char,
+                    describe.shortName(font),
+                    glyfName
+                )
+    return glyfName
+
+def width( font, glyphName ):
+    """Retrieve the width of the giving character for given font
+
+    The horizontal metrics table provides both the
+    width and the left side bearing, we should really
+    be using the left side bearing to adjust the
+    character, but that's a later project.
+    """
+    try:
+        return font['hmtx'].metrics[ glyphName ][0]
+    except KeyError:
+        raise ValueError( """Couldn't find glyph for glyphName %r"""%(
+            glyphName,
+        ))
+
+def lineHeight( font ):
+    """Get the base-line to base-line height for the font
+
+    XXX
+        There is some fudging going on here as I
+        workaround what appears to be a problem with the
+        specification for sTypoDescender, which states
+        that it should normally be a negative value, but
+        winds up being positive in at least one font that
+        defines points below the zero axis.
+
+    XXX The entire OS/2 table doesn't appear in a few
+        fonts (symbol fonts in particular), such as Corel's
+        BeeHive and BlackLight 686.
+    """
+    return charHeight(font) + font['OS/2'].sTypoLineGap
+
+def charHeight( font ):
+    """Determine the general character height for the font (for scaling)"""
+    ascent = font['OS/2'].sTypoAscender
+    descent = font['OS/2'].sTypoDescender
+    if descent > 0:
+        descent = - descent
+    return ascent - descent
+
+def charDescent( font ):
+    """Determine the general descent for the font (for scaling)"""
+    return font['OS/2'].sTypoDescender
+

ttfquery/guessdescription.py

@@ -0,0 +1,135 @@
+"""Heuristic attempting to extract descriptions from font names
+
+This should only be used as a backup in case there is
+no proper available querying mechanism (i.e. fonttools),
+and even then, we really would rather avoid using this
+extremely fragile mechanism.
+
+Basically what happens is that a name compression function
+is run over the font name, as seen in the Windows Registry,
+producing a base name and a set of modifiers, with the
+modifiers being the weight (as a string) and a flag
+indicating whether the font appears to be italicised.
+
+XXX This is English-specific and entirely dependent on the
+    naming conventions commonly seen when naming fonts, so
+    there will be a considerable number of cases where the
+    resulting name and flags will be incorrect.
+"""
+WEIGHTS = [
+    'demibold', 'extrabold', 'semibold', 'ultrabold', 'bold',
+    'ultralight', 'extralight', 'light',
+    'heavy',
+    'medium',
+    'thin',
+]
+IGNORE_MODIFIERS = [
+    "unicode",
+    "regular",
+    "normal",
+    "bt",
+    "let",
+##	"mt",
+    'itc',
+    "(truetype)",
+    'ft',
+    'win95bt',
+    'plain:1.0',
+    'plain',
+    'plain:',
+]
+WEIGHT_SYNONYMS = [
+    ('lt', 'light'),
+    ('lite', 'light'),
+    ('bolditalic','bold'),
+    ('demi', 'demibold'),
+    ('semi', 'semibold'),
+]
+WEIGHT_MODIFIERS = [
+    'extra', 'ultra'
+]
+    
+
+ITALIC_INDICATORS = [
+    'italic', 'ital','itali', 'it', 'bolditalic',
+]
+SYSTEM_FONTS = {}
+
+def interpretModifiers( name ):
+    """Heuristic attempt to get weight and italic data from font-name
+
+    return base_font_name, (weight, italic)
+    """
+    name = name.replace('_',' ').replace('-',' ').lower().split()
+    weight = "normal"
+    for w in WEIGHTS:
+        if w in name:
+            weight = w
+            while w in name:
+                name.remove( w )
+            break
+    for w,syn in WEIGHT_SYNONYMS:
+        if w in name:
+            weight = syn
+            while w in name:
+                name.remove( w )
+    if weight in ('bold','light'):
+        # "extra bold", "extra light", etceteras
+        for w in WEIGHT_MODIFIERS:
+            if w in name:
+                weight = w+weight
+                while w in name:
+                    name.remove( w )
+                break
+    # XXX should look for "extra" and "ultra" w/out bold/light,
+    # but that that point we're basically just shooting blind
+    # as to which it is...
+    for i in ITALIC_INDICATORS:
+        if i in name:
+            italic = 1
+            while i in name:
+                name.remove( i )
+            break
+    else:
+        italic = 0
+    for i in IGNORE_MODIFIERS:
+        while i in name:
+            name.remove( i )
+    name = " ".join( name )
+    if not name.strip():
+        # MT Extra
+        raise ValueError( "name reduced to null by name compression" )
+        return None,(None,None)
+    return name, (weight, italic)
+
+
+def add( name, file ):
+    """Add a font with name and file to this module's registry"""
+    name, style = interpretModifiers( name )
+    if name is not None:
+        SYSTEM_FONTS.setdefault(name, {})[style] = file
+    return name, style
+def get( name, style=None ):
+    """Get a font by name and optional style
+
+    Style defaults to ("normal", 0)
+    """
+    name, tstyle = interpretModifiers( name )
+    if tstyle != style and style is None:
+        style = tstyle
+    set = SYSTEM_FONTS.get( name )
+    if set:
+        if style in set:
+            return set[style]
+        # try match on italics
+        for key, value in set.items():
+            if key[1] == style[1]:
+                return value
+        # try match on weight
+        for key, value in set.items():
+            if key[0] == style[0]:
+                return value
+        # well, there's at least one font here, use it...
+        for key, value in set.items():
+            return value
+    return None

ttfquery/scriptregistry.py

@@ -0,0 +1,37 @@
+"""Provides a single font metadata cache from which multiple programs can run
+
+Note: on systems without an XDG_CACHE_HOME or a HOME environment variable 
+this will store the cache in the *code* directory for ttfquery, which is
+obviously sub-optimal.
+
+`registryFile` -- calculated at load time as the location for the cache
+"""
+from ttfquery import ttffiles
+import os, logging 
+log = logging.getLogger( __name__ )
+
+### more robust registry-file location by John Hunter...
+if 'XDG_CACHE_HOME' in os.environ:
+    registryFile = os.path.join( os.environ['XDG_CACHE_HOME'], "ttfquery", "font.cache")
+elif 'HOME' in os.environ:
+    registryFile = os.path.join( os.environ['HOME'], ".font.cache")
+else:
+    # OpenGLContext uses the Application Data directory for win32,
+    # should consider porting that code here...
+    registryFile = os.path.join( os.path.split(__file__)[0], "font.cache")
+
+registry = None
+def get_registry():
+    """Get a singleton registry instance in `registryFile` scanning if new"""
+    global registry
+    if registry is not None:
+        return registry
+    if os.path.isfile( registryFile ):
+        registry = ttffiles.load( registryFile )
+    else:
+        registry = ttffiles.Registry()
+        log.info( """Scanning for system fonts...""" )
+        new,failed = registry.scan( printErrors = 1, force = 0)
+        log.info( """Scan complete. Saving to %r\n""", registryFile,)
+        registry.save(registryFile)
+    return registry

ttfquery/ttffamily.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+"""Query for font-members of a particular family"""
+from __future__ import print_function
+from ttfquery import ttffiles
+import sys, logging
+log = logging.getLogger( __name__ )
+
+def get_options():
+    options = ttffiles.get_options()
+    options.description = 'Find all members of a particular font-family'
+    options.add_argument(
+        'major', help='The major family component, e.g. ANY or SANS, SCRIPT, SERIF, SERIF-OLD, SERIF-SLAB, etc',
+        default='ANY',
+        nargs='?',
+    )
+    options.add_argument(
+        'minor', help='The minor family component, or all if unspecified',
+        nargs='?',
+        default=None,
+    )
+    return options
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+    options = get_options().parse_args()
+    registry = ttffiles.registry_for_options(options)
+    search(registry,options.major,options.minor)
+    return 0
+
+def search(registry,major,minor=None):
+    for fontName in registry.familyMembers(major,minor):
+        print('F', fontName)
+        for specific in registry.fontMembers( fontName ):
+            print(' ', registry.fontFile( specific ))
+
+if __name__ == "__main__":
+    main()