summaryrefslogtreecommitdiff
path: root/third_party/freetype-py/freetype
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/freetype-py/freetype')
-rw-r--r--third_party/freetype-py/freetype/__init__.py1989
-rw-r--r--third_party/freetype-py/freetype/ft_enums/__init__.py121
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_encodings.py108
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_face_flags.py134
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_fstypes.py65
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_glyph_bbox_modes.py37
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_glyph_formats.py58
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_kerning_modes.py31
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_lcd_filters.py51
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_load_flags.py154
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_load_targets.py70
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_open_modes.py45
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_outline_flags.py87
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_pixel_modes.py77
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_render_modes.py57
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_stroker_borders.py38
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_stroker_linecaps.py34
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_stroker_linejoins.py36
-rw-r--r--third_party/freetype-py/freetype/ft_enums/ft_style_flags.py28
-rw-r--r--third_party/freetype-py/freetype/ft_enums/tt_adobe_ids.py38
-rw-r--r--third_party/freetype-py/freetype/ft_enums/tt_apple_ids.py53
-rw-r--r--third_party/freetype-py/freetype/ft_enums/tt_mac_ids.py117
-rw-r--r--third_party/freetype-py/freetype/ft_enums/tt_mac_langids.py376
-rw-r--r--third_party/freetype-py/freetype/ft_enums/tt_ms_ids.py68
-rw-r--r--third_party/freetype-py/freetype/ft_enums/tt_ms_langids.py751
-rw-r--r--third_party/freetype-py/freetype/ft_enums/tt_name_ids.py93
-rw-r--r--third_party/freetype-py/freetype/ft_enums/tt_platforms.py63
-rw-r--r--third_party/freetype-py/freetype/ft_errors.py105
-rw-r--r--third_party/freetype-py/freetype/ft_structs.py944
-rw-r--r--third_party/freetype-py/freetype/ft_types.py155
30 files changed, 5983 insertions, 0 deletions
diff --git a/third_party/freetype-py/freetype/__init__.py b/third_party/freetype-py/freetype/__init__.py
new file mode 100644
index 0000000..3f9934e
--- /dev/null
+++ b/third_party/freetype-py/freetype/__init__.py
@@ -0,0 +1,1989 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2014 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+'''
+FreeType high-level python API
+
+This the bindings for the high-level API of FreeType (that must be installed
+somewhere on your system).
+
+Note: C Library will be searched using the ctypes.util.find_library. However,
+ this search might fail. In such a case (or for other reasons), you may
+ have to specify an explicit path below.
+'''
+import os
+import sys
+import platform
+from ctypes import *
+from freetype.ft_types import *
+from freetype.ft_enums import *
+from freetype.ft_errors import *
+from freetype.ft_structs import *
+import ctypes.util
+
+# Hack to get unicode class in python3
+PY3 = sys.version_info[0] == 3
+if PY3: unicode = str
+
+
+__dll__ = None
+__handle__ = None
+
+# on windows all ctypes does when checking for the library
+# is to append .dll to the end and look for an exact match
+# within any entry in PATH.
+filename = ctypes.util.find_library('freetype')
+
+if filename is None:
+ if platform.system() == 'Windows':
+ # Check current working directory for dll as ctypes fails to do so
+ filename = os.path.join(os.path.realpath('.'), 'freetype.dll')
+ else:
+ filename = 'libfreetype.so.6'
+
+try:
+ dll = ctypes.CDLL(filename)
+ _found = True
+except (OSError, TypeError):
+ _found = False
+
+if not _found:
+ raise RuntimeError('Freetype library not found')
+
+__dll__ = dll
+FT_Library_filename = filename
+
+# -----------------------------------------------------------------------------
+# High-level API of FreeType 2
+# -----------------------------------------------------------------------------
+FT_Init_FreeType = __dll__.FT_Init_FreeType
+FT_Done_FreeType = __dll__.FT_Done_FreeType
+FT_Library_Version = __dll__.FT_Library_Version
+
+def __del_library__(self):
+ global __handle__
+ if __handle__:
+ try:
+ FT_Done_FreeType(self)
+ __handle__ = None
+ except:
+ pass
+FT_Library.__del__ = __del_library__
+
+def get_handle():
+ '''
+ Get unique FT_Library handle
+ '''
+ global __handle__
+ if not __handle__:
+ __handle__ = FT_Library( )
+ error = FT_Init_FreeType( byref(__handle__) )
+ if error: raise FT_Exception(error)
+ try:
+ set_lcd_filter( FT_LCD_FILTER_DEFAULT )
+ except:
+ pass
+ if error: raise FT_Exception(error)
+ return __handle__
+
+def version():
+ '''
+ Return the version of the FreeType library being used as a tuple of
+ ( major version number, minor version number, patch version number )
+ '''
+ amajor = FT_Int()
+ aminor = FT_Int()
+ apatch = FT_Int()
+ library = get_handle()
+ FT_Library_Version(library, byref(amajor), byref(aminor), byref(apatch))
+ return (amajor.value, aminor.value, apatch.value)
+
+
+try:
+ FT_Library_SetLcdFilter= __dll__.FT_Library_SetLcdFilter
+except:
+ def FT_Library_SetLcdFilter (*args, **kwargs):
+ return 0
+if version()>=(2,4,0):
+ FT_Library_SetLcdFilterWeights = __dll__.FT_Library_SetLcdFilterWeights
+FT_New_Face = __dll__.FT_New_Face
+FT_New_Memory_Face = __dll__.FT_New_Memory_Face
+FT_Open_Face = __dll__.FT_Open_Face
+FT_Attach_File = __dll__.FT_Attach_File
+FT_Attach_Stream = __dll__.FT_Attach_Stream
+if version()>=(2,4,2):
+ FT_Reference_Face = __dll__.FT_Reference_Face
+FT_Done_Face = __dll__.FT_Done_Face
+FT_Done_Glyph = __dll__.FT_Done_Glyph
+FT_Select_Size = __dll__.FT_Select_Size
+FT_Request_Size = __dll__.FT_Request_Size
+FT_Set_Char_Size = __dll__.FT_Set_Char_Size
+FT_Set_Pixel_Sizes = __dll__.FT_Set_Pixel_Sizes
+FT_Load_Glyph = __dll__.FT_Load_Glyph
+FT_Load_Char = __dll__.FT_Load_Char
+FT_Set_Transform = __dll__.FT_Set_Transform
+FT_Render_Glyph = __dll__.FT_Render_Glyph
+FT_Get_Kerning = __dll__.FT_Get_Kerning
+FT_Get_Track_Kerning = __dll__.FT_Get_Track_Kerning
+FT_Get_Glyph_Name = __dll__.FT_Get_Glyph_Name
+FT_Get_Glyph = __dll__.FT_Get_Glyph
+
+FT_Glyph_Get_CBox = __dll__.FT_Glyph_Get_CBox
+
+FT_Get_Postscript_Name = __dll__.FT_Get_Postscript_Name
+FT_Get_Postscript_Name.restype = c_char_p
+FT_Select_Charmap = __dll__.FT_Select_Charmap
+FT_Set_Charmap = __dll__.FT_Set_Charmap
+FT_Get_Charmap_Index = __dll__.FT_Get_Charmap_Index
+FT_Get_CMap_Language_ID= __dll__.FT_Get_CMap_Language_ID
+FT_Get_CMap_Format = __dll__.FT_Get_CMap_Format
+FT_Get_Char_Index = __dll__.FT_Get_Char_Index
+FT_Get_First_Char = __dll__.FT_Get_First_Char
+FT_Get_Next_Char = __dll__.FT_Get_Next_Char
+FT_Get_Name_Index = __dll__.FT_Get_Name_Index
+FT_Get_SubGlyph_Info = __dll__.FT_Get_SubGlyph_Info
+if version()>=(2,3,8):
+ FT_Get_FSType_Flags = __dll__.FT_Get_FSType_Flags
+ FT_Get_FSType_Flags.restype = c_ushort
+
+FT_Get_X11_Font_Format = __dll__.FT_Get_X11_Font_Format
+FT_Get_X11_Font_Format.restype = c_char_p
+
+FT_Get_Sfnt_Name_Count = __dll__.FT_Get_Sfnt_Name_Count
+FT_Get_Sfnt_Name = __dll__.FT_Get_Sfnt_Name
+FT_Get_Advance = __dll__.FT_Get_Advance
+
+
+FT_Outline_GetInsideBorder = __dll__.FT_Outline_GetInsideBorder
+FT_Outline_GetOutsideBorder = __dll__.FT_Outline_GetOutsideBorder
+FT_Outline_Get_BBox = __dll__.FT_Outline_Get_BBox
+FT_Outline_Get_CBox = __dll__.FT_Outline_Get_CBox
+FT_Stroker_New = __dll__.FT_Stroker_New
+FT_Stroker_Set = __dll__.FT_Stroker_Set
+FT_Stroker_Rewind = __dll__.FT_Stroker_Rewind
+FT_Stroker_ParseOutline = __dll__.FT_Stroker_ParseOutline
+FT_Stroker_BeginSubPath = __dll__.FT_Stroker_BeginSubPath
+FT_Stroker_EndSubPath = __dll__.FT_Stroker_EndSubPath
+FT_Stroker_LineTo = __dll__.FT_Stroker_LineTo
+FT_Stroker_ConicTo = __dll__.FT_Stroker_ConicTo
+FT_Stroker_CubicTo = __dll__.FT_Stroker_CubicTo
+FT_Stroker_GetBorderCounts = __dll__.FT_Stroker_GetBorderCounts
+FT_Stroker_ExportBorder = __dll__.FT_Stroker_ExportBorder
+FT_Stroker_GetCounts = __dll__.FT_Stroker_GetCounts
+FT_Stroker_Export = __dll__.FT_Stroker_Export
+FT_Stroker_Done = __dll__.FT_Stroker_Done
+FT_Glyph_Stroke = __dll__.FT_Glyph_Stroke
+FT_Glyph_StrokeBorder = __dll__.FT_Glyph_StrokeBorder
+FT_Glyph_To_Bitmap = __dll__.FT_Glyph_To_Bitmap
+
+
+
+# -----------------------------------------------------------------------------
+# Stand alone functions
+# -----------------------------------------------------------------------------
+def set_lcd_filter(filt):
+ '''
+ This function is used to apply color filtering to LCD decimated bitmaps,
+ like the ones used when calling FT_Render_Glyph with FT_RENDER_MODE_LCD or
+ FT_RENDER_MODE_LCD_V.
+
+ **Note**
+
+ This feature is always disabled by default. Clients must make an explicit
+ call to this function with a 'filter' value other than FT_LCD_FILTER_NONE
+ in order to enable it.
+
+ Due to PATENTS covering subpixel rendering, this function doesn't do
+ anything except returning 'FT_Err_Unimplemented_Feature' if the
+ configuration macro FT_CONFIG_OPTION_SUBPIXEL_RENDERING is not defined in
+ your build of the library, which should correspond to all default builds of
+ FreeType.
+
+ The filter affects glyph bitmaps rendered through FT_Render_Glyph,
+ FT_Outline_Get_Bitmap, FT_Load_Glyph, and FT_Load_Char.
+
+ It does not affect the output of FT_Outline_Render and
+ FT_Outline_Get_Bitmap.
+
+ If this feature is activated, the dimensions of LCD glyph bitmaps are
+ either larger or taller than the dimensions of the corresponding outline
+ with regards to the pixel grid. For example, for FT_RENDER_MODE_LCD, the
+ filter adds up to 3 pixels to the left, and up to 3 pixels to the right.
+
+ The bitmap offset values are adjusted correctly, so clients shouldn't need
+ to modify their layout and glyph positioning code when enabling the filter.
+ '''
+ library = get_handle()
+ error = FT_Library_SetLcdFilter(library, filt)
+ if error: raise FT_Exception(error)
+
+
+
+def set_lcd_filter_weights(a,b,c,d,e):
+ '''
+ Use this function to override the filter weights selected by
+ FT_Library_SetLcdFilter. By default, FreeType uses the quintuple (0x00,
+ 0x55, 0x56, 0x55, 0x00) for FT_LCD_FILTER_LIGHT, and (0x10, 0x40, 0x70,
+ 0x40, 0x10) for FT_LCD_FILTER_DEFAULT and FT_LCD_FILTER_LEGACY.
+
+ **Note**
+
+ Only available if version > 2.4.0
+ '''
+ if version()>=(2,4,0):
+ library = get_handle()
+ weights = FT_Char(5)(a,b,c,d,e)
+ error = FT_Library_SetLcdFilterWeights(library, weights)
+ if error: raise FT_Exception(error)
+ else:
+ raise RuntimeError(
+ 'set_lcd_filter_weights require freetype > 2.4.0')
+
+
+def _encode_filename(filename):
+ encoded = filename.encode(sys.getfilesystemencoding())
+ if "?" not in filename and b"?" in encoded:
+ # A bug, decoding mbcs always ignore exception, still isn't fixed in Python 2,
+ # view http://bugs.python.org/issue850997 for detail
+ raise UnicodeError()
+ return encoded
+
+
+
+# -----------------------------------------------------------------------------
+# Direct wrapper (simple renaming)
+# -----------------------------------------------------------------------------
+Vector = FT_Vector
+Matrix = FT_Matrix
+
+
+
+# -----------------------------------------------------------------------------
+class BBox( object ):
+ '''
+ FT_BBox wrapper.
+
+ A structure used to hold an outline's bounding box, i.e., the coordinates
+ of its extrema in the horizontal and vertical directions.
+
+ **Note**
+
+ The bounding box is specified with the coordinates of the lower left and
+ the upper right corner. In PostScript, those values are often called
+ (llx,lly) and (urx,ury), respectively.
+
+ If 'yMin' is negative, this value gives the glyph's descender. Otherwise,
+ the glyph doesn't descend below the baseline. Similarly, if 'ymax' is
+ positive, this value gives the glyph's ascender.
+
+ 'xMin' gives the horizontal distance from the glyph's origin to the left
+ edge of the glyph's bounding box. If 'xMin' is negative, the glyph
+ extends to the left of the origin.
+ '''
+
+ def __init__(self, bbox):
+ '''
+ Create a new BBox object.
+
+ :param bbox: a FT_BBox or a tuple of 4 values
+ '''
+ if type(bbox) is FT_BBox:
+ self._FT_BBox = bbox
+ else:
+ self._FT_BBox = FT_BBox(*bbox)
+
+ xMin = property(lambda self: self._FT_BBox.xMin,
+ doc = 'The horizontal minimum (left-most).')
+
+ yMin = property(lambda self: self._FT_BBox.yMin,
+ doc = 'The vertical minimum (bottom-most).')
+
+ xMax = property(lambda self: self._FT_BBox.xMax,
+ doc = 'The horizontal maximum (right-most).')
+
+ yMax = property(lambda self: self._FT_BBox.yMax,
+ doc = 'The vertical maximum (top-most).')
+
+
+
+
+
+# -----------------------------------------------------------------------------
+class GlyphMetrics( object ):
+ '''
+
+ A structure used to model the metrics of a single glyph. The values are
+ expressed in 26.6 fractional pixel format; if the flag FT_LOAD_NO_SCALE has
+ been used while loading the glyph, values are expressed in font units
+ instead.
+
+ **Note**
+
+ If not disabled with FT_LOAD_NO_HINTING, the values represent dimensions of
+ the hinted glyph (in case hinting is applicable).
+
+ Stroking a glyph with an outside border does not increase ‘horiAdvance’ or
+ ‘vertAdvance’; you have to manually adjust these values to account for the
+ added width and height.
+ '''
+
+ def __init__(self, metrics ):
+ '''
+ Create a new GlyphMetrics object.
+
+ :param metrics: a FT_Glyph_Metrics
+ '''
+ self._FT_Glyph_Metrics = metrics
+
+ width = property( lambda self: self._FT_Glyph_Metrics.width,
+ doc = '''The glyph's width.''' )
+
+ height = property( lambda self: self._FT_Glyph_Metrics.height,
+ doc = '''The glyph's height.''' )
+
+ horiBearingX = property( lambda self: self._FT_Glyph_Metrics.horiBearingX,
+ doc = '''Left side bearing for horizontal layout.''' )
+
+ horiBearingY = property( lambda self: self._FT_Glyph_Metrics.horiBearingY,
+ doc = '''Top side bearing for horizontal layout.''' )
+
+ horiAdvance = property( lambda self: self._FT_Glyph_Metrics.horiAdvance,
+ doc = '''Advance width for horizontal layout.''' )
+
+ vertBearingX = property( lambda self: self._FT_Glyph_Metrics.vertBearingX,
+ doc = '''Left side bearing for vertical layout.''' )
+
+ vertBearingY = property( lambda self: self._FT_Glyph_Metrics.vertBearingY,
+ doc = '''Top side bearing for vertical layout. Larger positive values
+ mean further below the vertical glyph origin.''' )
+
+ vertAdvance = property( lambda self: self._FT_Glyph_Metrics.vertAdvance,
+ doc = '''Advance height for vertical layout. Positive values mean the
+ glyph has a positive advance downward.''' )
+
+
+# -----------------------------------------------------------------------------
+class SizeMetrics( object ):
+ '''
+ The size metrics structure gives the metrics of a size object.
+
+ **Note**
+
+ The scaling values, if relevant, are determined first during a size
+ changing operation. The remaining fields are then set by the driver. For
+ scalable formats, they are usually set to scaled values of the
+ corresponding fields in Face.
+
+ Note that due to glyph hinting, these values might not be exact for certain
+ fonts. Thus they must be treated as unreliable with an error margin of at
+ least one pixel!
+
+ Indeed, the only way to get the exact metrics is to render all glyphs. As
+ this would be a definite performance hit, it is up to client applications
+ to perform such computations.
+
+ The SizeMetrics structure is valid for bitmap fonts also.
+ '''
+
+ def __init__(self, metrics ):
+ '''
+ Create a new SizeMetrics object.
+
+ :param metrics: a FT_SizeMetrics
+ '''
+ self._FT_Size_Metrics = metrics
+
+ x_ppem = property( lambda self: self._FT_Size_Metrics.x_ppem,
+ doc = '''The width of the scaled EM square in pixels, hence the term
+ 'ppem' (pixels per EM). It is also referred to as 'nominal
+ width'.''' )
+
+ y_ppem = property( lambda self: self._FT_Size_Metrics.y_ppem,
+ doc = '''The height of the scaled EM square in pixels, hence the term
+ 'ppem' (pixels per EM). It is also referred to as 'nominal
+ height'.''' )
+
+ x_scale = property( lambda self: self._FT_Size_Metrics.x_scale,
+ doc = '''A 16.16 fractional scaling value used to convert horizontal
+ metrics from font units to 26.6 fractional pixels. Only
+ relevant for scalable font formats.''' )
+
+ y_scale = property( lambda self: self._FT_Size_Metrics.y_scale,
+ doc = '''A 16.16 fractional scaling value used to convert vertical
+ metrics from font units to 26.6 fractional pixels. Only
+ relevant for scalable font formats.''' )
+
+ ascender = property( lambda self: self._FT_Size_Metrics.ascender,
+ doc = '''The ascender in 26.6 fractional pixels. See Face for the
+ details.''' )
+
+ descender = property( lambda self: self._FT_Size_Metrics.descender,
+ doc = '''The descender in 26.6 fractional pixels. See Face for the
+ details.''' )
+
+ height = property( lambda self: self._FT_Size_Metrics.height,
+ doc = '''The height in 26.6 fractional pixels. See Face for the details.''' )
+
+ max_advance = property(lambda self: self._FT_Size_Metrics.max_advance,
+ doc = '''The maximal advance width in 26.6 fractional pixels. See
+ Face for the details.''' )
+
+
+
+# -----------------------------------------------------------------------------
+class BitmapSize( object ):
+ '''
+ FT_Bitmap_Size wrapper
+
+ This structure models the metrics of a bitmap strike (i.e., a set of glyphs
+ for a given point size and resolution) in a bitmap font. It is used for the
+ 'available_sizes' field of Face.
+
+ **Note**
+
+ Windows FNT: The nominal size given in a FNT font is not reliable. Thus
+ when the driver finds it incorrect, it sets 'size' to some calculated
+ values and sets 'x_ppem' and 'y_ppem' to the pixel width and height given
+ in the font, respectively.
+
+ TrueType embedded bitmaps: 'size', 'width', and 'height' values are not
+ contained in the bitmap strike itself. They are computed from the global
+ font parameters.
+ '''
+ def __init__(self, size ):
+ '''
+ Create a new SizeMetrics object.
+
+ :param size: a FT_Bitmap_Size
+ '''
+ self._FT_Bitmap_Size = size
+
+ height = property( lambda self: self._FT_Bitmap_Size.height,
+ doc = '''The vertical distance, in pixels, between two consecutive
+ baselines. It is always positive.''')
+
+ width = property( lambda self: self._FT_Bitmap_Size.width,
+ doc = '''The average width, in pixels, of all glyphs in the strike.''')
+
+ size = property( lambda self: self._FT_Bitmap_Size.size,
+ doc = '''The nominal size of the strike in 26.6 fractional points. This
+ field is not very useful.''')
+
+ x_ppem = property( lambda self: self._FT_Bitmap_Size.x_ppem,
+ doc = '''The horizontal ppem (nominal width) in 26.6 fractional
+ pixels.''')
+
+ y_ppem = property( lambda self: self._FT_Bitmap_Size.y_ppem,
+ doc = '''The vertical ppem (nominal width) in 26.6 fractional
+ pixels.''')
+
+
+# -----------------------------------------------------------------------------
+class Bitmap(object):
+ '''
+ FT_Bitmap wrapper
+
+ A structure used to describe a bitmap or pixmap to the raster. Note that we
+ now manage pixmaps of various depths through the 'pixel_mode' field.
+
+ *Note*:
+
+ For now, the only pixel modes supported by FreeType are mono and
+ grays. However, drivers might be added in the future to support more
+ 'colorful' options.
+ '''
+ def __init__(self, bitmap):
+ '''
+ Create a new Bitmap object.
+
+ :param bitmap: a FT_Bitmap
+ '''
+ self._FT_Bitmap = bitmap
+
+ rows = property(lambda self: self._FT_Bitmap.rows,
+ doc = '''The number of bitmap rows.''')
+
+ width = property(lambda self: self._FT_Bitmap.width,
+ doc = '''The number of pixels in bitmap row.''')
+
+ pitch = property(lambda self: self._FT_Bitmap.pitch,
+ doc = '''The pitch's absolute value is the number of bytes taken by one
+ bitmap row, including padding. However, the pitch is positive
+ when the bitmap has a 'down' flow, and negative when it has an
+ 'up' flow. In all cases, the pitch is an offset to add to a
+ bitmap pointer in order to go down one row.
+
+ Note that 'padding' means the alignment of a bitmap to a byte
+ border, and FreeType functions normally align to the smallest
+ possible integer value.
+
+ For the B/W rasterizer, 'pitch' is always an even number.
+
+ To change the pitch of a bitmap (say, to make it a multiple of
+ 4), use FT_Bitmap_Convert. Alternatively, you might use callback
+ functions to directly render to the application's surface; see
+ the file 'example2.py' in the tutorial for a demonstration.''')
+
+ def _get_buffer(self):
+ data = [self._FT_Bitmap.buffer[i] for i in range(self.rows*self.pitch)]
+ return data
+ buffer = property(_get_buffer,
+ doc = '''A typeless pointer to the bitmap buffer. This value should be
+ aligned on 32-bit boundaries in most cases.''')
+
+ num_grays = property(lambda self: self._FT_Bitmap.num_grays,
+ doc = '''This field is only used with FT_PIXEL_MODE_GRAY; it gives
+ the number of gray levels used in the bitmap.''')
+
+ pixel_mode = property(lambda self: self._FT_Bitmap.pixel_mode,
+ doc = '''The pixel mode, i.e., how pixel bits are stored. See
+ FT_Pixel_Mode for possible values.''')
+
+ palette_mode = property(lambda self: self._FT_Bitmap.palette_mode,
+ doc ='''This field is intended for paletted pixel modes; it
+ indicates how the palette is stored. Not used currently.''')
+
+ palette = property(lambda self: self._FT_Bitmap.palette,
+ doc = '''A typeless pointer to the bitmap palette; this field is
+ intended for paletted pixel modes. Not used currently.''')
+
+
+
+
+# -----------------------------------------------------------------------------
+class Charmap( object ):
+ '''
+ FT_Charmap wrapper.
+
+ A handle to a given character map. A charmap is used to translate character
+ codes in a given encoding into glyph indexes for its parent's face. Some
+ font formats may provide several charmaps per font.
+
+ Each face object owns zero or more charmaps, but only one of them can be
+ 'active' and used by FT_Get_Char_Index or FT_Load_Char.
+
+ The list of available charmaps in a face is available through the
+ 'face.num_charmaps' and 'face.charmaps' fields of FT_FaceRec.
+
+ The currently active charmap is available as 'face.charmap'. You should
+ call FT_Set_Charmap to change it.
+
+ **Note**:
+
+ When a new face is created (either through FT_New_Face or FT_Open_Face),
+ the library looks for a Unicode charmap within the list and automatically
+ activates it.
+
+ **See also**:
+
+ See FT_CharMapRec for the publicly accessible fields of a given character
+ map.
+ '''
+
+ def __init__( self, charmap ):
+ '''
+ Create a new Charmap object.
+
+ Parameters:
+ -----------
+ charmap : a FT_Charmap
+ '''
+ self._FT_Charmap = charmap
+
+ encoding = property( lambda self: self._FT_Charmap.contents.encoding,
+ doc = '''An FT_Encoding tag identifying the charmap. Use this with
+ FT_Select_Charmap.''')
+
+ platform_id = property( lambda self: self._FT_Charmap.contents.platform_id,
+ doc = '''An ID number describing the platform for the following
+ encoding ID. This comes directly from the TrueType
+ specification and should be emulated for other
+ formats.''')
+
+ encoding_id = property( lambda self: self._FT_Charmap.contents.encoding_id,
+ doc = '''A platform specific encoding number. This also comes from
+ the TrueType specification and should be emulated
+ similarly.''')
+
+ def _get_encoding_name(self):
+ encoding = self.encoding
+ for key,value in FT_ENCODINGS.items():
+ if encoding == value:
+ return key
+ return 'Unknown encoding'
+ encoding_name = property( _get_encoding_name,
+ doc = '''A platform specific encoding name. This also comes from
+ the TrueType specification and should be emulated
+ similarly.''')
+
+ def _get_index( self ):
+ return FT_Get_Charmap_Index( self._FT_Charmap )
+ index = property( _get_index,
+ doc = '''The index into the array of character maps within the face to
+ which 'charmap' belongs. If an error occurs, -1 is returned.''')
+
+ def _get_cmap_language_id( self ):
+ return FT_Get_CMap_Language_ID( self._FT_Charmap )
+ cmap_language_id = property( _get_cmap_language_id,
+ doc = '''The language ID of 'charmap'. If 'charmap' doesn't
+ belong to a TrueType/sfnt face, just return 0 as the
+ default value.''')
+
+ def _get_cmap_format( self ):
+ return FT_Get_CMap_Format( self._FT_Charmap )
+ cmap_format = property( _get_cmap_format,
+ doc = '''The format of 'charmap'. If 'charmap' doesn't belong to a
+ TrueType/sfnt face, return -1.''')
+
+
+
+# -----------------------------------------------------------------------------
+class Outline( object ):
+ '''
+ FT_Outline wrapper.
+
+ This structure is used to describe an outline to the scan-line converter.
+ '''
+ def __init__( self, outline ):
+ '''
+ Create a new Outline object.
+
+ :param charmap: a FT_Outline
+ '''
+ self._FT_Outline = outline
+
+ n_contours = property(lambda self: self._FT_Outline.n_contours)
+ def _get_contours(self):
+ n = self._FT_Outline.n_contours
+ data = [self._FT_Outline.contours[i] for i in range(n)]
+ return data
+ contours = property(_get_contours,
+ doc = '''The number of contours in the outline.''')
+
+ n_points = property(lambda self: self._FT_Outline.n_points)
+ def _get_points(self):
+ n = self._FT_Outline.n_points
+ data = []
+ for i in range(n):
+ v = self._FT_Outline.points[i]
+ data.append( (v.x,v.y) )
+ return data
+ points = property( _get_points,
+ doc = '''The number of points in the outline.''')
+
+ def _get_tags(self):
+ n = self._FT_Outline.n_points
+ data = [self._FT_Outline.tags[i] for i in range(n)]
+ return data
+ tags = property(_get_tags,
+ doc = '''A list of 'n_points' chars, giving each outline point's type.
+
+ If bit 0 is unset, the point is 'off' the curve, i.e., a Bezier
+ control point, while it is 'on' if set.
+
+ Bit 1 is meaningful for 'off' points only. If set, it indicates a
+ third-order Bezier arc control point; and a second-order control
+ point if unset.
+
+ If bit 2 is set, bits 5-7 contain the drop-out mode (as defined
+ in the OpenType specification; the value is the same as the
+ argument to the SCANMODE instruction).
+
+ Bits 3 and 4 are reserved for internal purposes.''')
+
+ flags = property(lambda self: self._FT_Outline.flags,
+ doc = '''A set of bit flags used to characterize the outline and give
+ hints to the scan-converter and hinter on how to
+ convert/grid-fit it. See FT_OUTLINE_FLAGS.''')
+
+ def get_inside_border( self ):
+ '''
+ Retrieve the FT_StrokerBorder value corresponding to the 'inside'
+ borders of a given outline.
+
+ :return: The border index. FT_STROKER_BORDER_RIGHT for empty or invalid
+ outlines.
+ '''
+ return FT_Outline_GetInsideBorder( self._FT_Outline )
+
+ def get_outside_border( self ):
+ '''
+ Retrieve the FT_StrokerBorder value corresponding to the 'outside'
+ borders of a given outline.
+
+ :return: The border index. FT_STROKER_BORDER_RIGHT for empty or invalid
+ outlines.
+ '''
+ return FT_Outline_GetInsideBorder( self._FT_Outline )
+
+ def get_bbox(self):
+ '''
+ Compute the exact bounding box of an outline. This is slower than
+ computing the control box. However, it uses an advanced algorithm which
+ returns very quickly when the two boxes coincide. Otherwise, the
+ outline Bezier arcs are traversed to extract their extrema.
+ '''
+ bbox = FT_BBox()
+ error = FT_Outline_Get_BBox(byref(self._FT_Outline), byref(bbox))
+ if error: raise FT_Exception(error)
+ return bbox
+
+ def get_cbox(self):
+ '''
+ Return an outline's 'control box'. The control box encloses all the
+ outline's points, including Bezier control points. Though it coincides
+ with the exact bounding box for most glyphs, it can be slightly larger
+ in some situations (like when rotating an outline which contains Bezier
+ outside arcs).
+
+ Computing the control box is very fast, while getting the bounding box
+ can take much more time as it needs to walk over all segments and arcs
+ in the outline. To get the latter, you can use the 'ftbbox' component
+ which is dedicated to this single task.
+ '''
+ bbox = FT_BBox()
+ error = FT_Outline_Get_CBox(byref(self._FT_Outline), byref(bbox))
+ if error: raise FT_Exception(error)
+ return BBox(bbox)
+
+
+
+
+# -----------------------------------------------------------------------------
+class Glyph( object ):
+ '''
+ FT_Glyph wrapper.
+
+ The root glyph structure contains a given glyph image plus its advance
+ width in 16.16 fixed float format.
+ '''
+ def __init__( self, glyph ):
+ '''
+ Create Glyph object from an FT glyph.
+
+ :param glyph: valid FT_Glyph object
+ '''
+ self._FT_Glyph = glyph
+
+ def __del__( self ):
+ '''
+ Destroy glyph.
+ '''
+ FT_Done_Glyph( self._FT_Glyph )
+
+ def _get_format( self ):
+ return self._FT_Glyph.contents.format
+ format = property( _get_format,
+ doc = '''The format of the glyph's image.''')
+
+
+ def stroke( self, stroker, destroy=False ):
+ '''
+ Stroke a given outline glyph object with a given stroker.
+
+ :param stroker: A stroker handle.
+
+ :param destroy: A Boolean. If 1, the source glyph object is destroyed on
+ success.
+
+ **Note**:
+
+ The source glyph is untouched in case of error.
+ '''
+ error = FT_Glyph_Stroke( byref(self._FT_Glyph),
+ stroker._FT_Stroker, destroy )
+ if error: raise FT_Exception( error )
+
+ def to_bitmap( self, mode, origin, destroy=False ):
+ '''
+ Convert a given glyph object to a bitmap glyph object.
+
+ :param mode: An enumeration that describes how the data is rendered.
+
+ :param origin: A pointer to a vector used to translate the glyph image
+ before rendering. Can be 0 (if no translation). The origin is
+ expressed in 26.6 pixels.
+
+ :param destroy: A boolean that indicates that the original glyph image
+ should be destroyed by this function. It is never destroyed
+ in case of error.
+
+ **Note**:
+
+ This function does nothing if the glyph format isn't scalable.
+
+ The glyph image is translated with the 'origin' vector before
+ rendering.
+
+ The first parameter is a pointer to an FT_Glyph handle, that will be
+ replaced by this function (with newly allocated data). Typically, you
+ would use (omitting error handling):
+ '''
+ error = FT_Glyph_To_Bitmap( byref(self._FT_Glyph),
+ mode, origin, destroy)
+ if error: raise FT_Exception( error )
+ return BitmapGlyph( self._FT_Glyph )
+
+ def get_cbox(self, bbox_mode):
+ '''
+ Return an outline's 'control box'. The control box encloses all the
+ outline's points, including Bezier control points. Though it coincides
+ with the exact bounding box for most glyphs, it can be slightly larger
+ in some situations (like when rotating an outline which contains Bezier
+ outside arcs).
+
+ Computing the control box is very fast, while getting the bounding box
+ can take much more time as it needs to walk over all segments and arcs
+ in the outline. To get the latter, you can use the 'ftbbox' component
+ which is dedicated to this single task.
+
+ :param mode: The mode which indicates how to interpret the returned
+ bounding box values.
+
+ **Note**:
+
+ Coordinates are relative to the glyph origin, using the y upwards
+ convention.
+
+ If the glyph has been loaded with FT_LOAD_NO_SCALE, 'bbox_mode' must be
+ set to FT_GLYPH_BBOX_UNSCALED to get unscaled font units in 26.6 pixel
+ format. The value FT_GLYPH_BBOX_SUBPIXELS is another name for this
+ constant.
+
+ Note that the maximum coordinates are exclusive, which means that one
+ can compute the width and height of the glyph image (be it in integer
+ or 26.6 pixels) as:
+
+ width = bbox.xMax - bbox.xMin;
+ height = bbox.yMax - bbox.yMin;
+
+ Note also that for 26.6 coordinates, if 'bbox_mode' is set to
+ FT_GLYPH_BBOX_GRIDFIT, the coordinates will also be grid-fitted, which
+ corresponds to:
+
+ bbox.xMin = FLOOR(bbox.xMin);
+ bbox.yMin = FLOOR(bbox.yMin);
+ bbox.xMax = CEILING(bbox.xMax);
+ bbox.yMax = CEILING(bbox.yMax);
+
+ To get the bbox in pixel coordinates, set 'bbox_mode' to
+ FT_GLYPH_BBOX_TRUNCATE.
+
+ To get the bbox in grid-fitted pixel coordinates, set 'bbox_mode' to
+ FT_GLYPH_BBOX_PIXELS.
+ '''
+ bbox = FT_BBox()
+ error = FT_Glyph_Get_CBox(byref(self._FT_Glyph), bbox_mode,byref(bbox))
+ if error: raise FT_Exception(error)
+ return BBox(bbox)
+
+
+
+# -----------------------------------------------------------------------------
+class BitmapGlyph( object ):
+ '''
+ FT_BitmapGlyph wrapper.
+
+ A structure used for bitmap glyph images. This really is a 'sub-class' of
+ FT_GlyphRec.
+ '''
+ def __init__( self, glyph ):
+ '''
+ Create Glyph object from an FT glyph.
+
+ Parameters:
+ -----------
+ glyph: valid FT_Glyph object
+ '''
+ self._FT_BitmapGlyph = cast(glyph, FT_BitmapGlyph)
+
+ # def __del__( self ):
+ # '''
+ # Destroy glyph.
+ # '''
+ # FT_Done_Glyph( cast(self._FT_BitmapGlyph, FT_Glyph) )
+
+
+ def _get_format( self ):
+ return self._FT_BitmapGlyph.contents.format
+ format = property( _get_format,
+ doc = '''The format of the glyph's image.''')
+
+
+ def _get_bitmap( self ):
+ return Bitmap( self._FT_BitmapGlyph.contents.bitmap )
+ bitmap = property( _get_bitmap,
+ doc = '''A descriptor for the bitmap.''')
+
+
+ def _get_left( self ):
+ return self._FT_BitmapGlyph.contents.left
+ left = property( _get_left,
+ doc = '''The left-side bearing, i.e., the horizontal distance from the
+ current pen position to the left border of the glyph bitmap.''')
+
+
+ def _get_top( self ):
+ return self._FT_BitmapGlyph.contents.top
+ top = property( _get_top,
+ doc = '''The top-side bearing, i.e., the vertical distance from the
+ current pen position to the top border of the glyph bitmap.
+ This distance is positive for upwards y!''')
+
+
+# -----------------------------------------------------------------------------
+class GlyphSlot( object ):
+ '''
+ FT_GlyphSlot wrapper.
+
+ FreeType root glyph slot class structure. A glyph slot is a container where
+ individual glyphs can be loaded, be they in outline or bitmap format.
+ '''
+
+ def __init__( self, slot ):
+ '''
+ Create GlyphSlot object from an FT glyph slot.
+
+ Parameters:
+ -----------
+ glyph: valid FT_GlyphSlot object
+ '''
+ self._FT_GlyphSlot = slot
+
+ def get_glyph( self ):
+ '''
+ A function used to extract a glyph image from a slot. Note that the
+ created FT_Glyph object must be released with FT_Done_Glyph.
+ '''
+ aglyph = FT_Glyph()
+ error = FT_Get_Glyph( self._FT_GlyphSlot, byref(aglyph) )
+ if error: raise FT_Exception( error )
+ return Glyph( aglyph )
+
+ def _get_bitmap( self ):
+ return Bitmap( self._FT_GlyphSlot.contents.bitmap )
+ bitmap = property( _get_bitmap,
+ doc = '''This field is used as a bitmap descriptor when the slot format
+ is FT_GLYPH_FORMAT_BITMAP. Note that the address and content of
+ the bitmap buffer can change between calls of FT_Load_Glyph and
+ a few other functions.''')
+
+ def _get_metrics( self ):
+ return GlyphMetrics( self._FT_GlyphSlot.contents.metrics )
+ metrics = property( _get_metrics,
+ doc = '''The metrics of the last loaded glyph in the slot. The returned
+ values depend on the last load flags (see the FT_Load_Glyph API
+ function) and can be expressed either in 26.6 fractional pixels or font
+ units. Note that even when the glyph image is transformed, the metrics
+ are not.''')
+
+ def _get_next( self ):
+ return GlyphSlot( self._FT_GlyphSlot.contents.next )
+ next = property( _get_next,
+ doc = '''In some cases (like some font tools), several glyph slots per
+ face object can be a good thing. As this is rare, the glyph slots
+ are listed through a direct, single-linked list using its 'next'
+ field.''')
+
+ advance = property( lambda self: self._FT_GlyphSlot.contents.advance,
+ doc = '''This shorthand is, depending on FT_LOAD_IGNORE_TRANSFORM, the
+ transformed advance width for the glyph (in 26.6 fractional
+ pixel format). As specified with FT_LOAD_VERTICAL_LAYOUT, it
+ uses either the 'horiAdvance' or the 'vertAdvance' value of
+ 'metrics' field.''')
+
+ def _get_outline( self ):
+ return Outline( self._FT_GlyphSlot.contents.outline )
+ outline = property( _get_outline,
+ doc = '''The outline descriptor for the current glyph image if its
+ format is FT_GLYPH_FORMAT_OUTLINE. Once a glyph is loaded,
+ 'outline' can be transformed, distorted, embolded,
+ etc. However, it must not be freed.''')
+
+ format = property( lambda self: self._FT_GlyphSlot.contents.format,
+ doc = '''This field indicates the format of the image contained in the
+ glyph slot. Typically FT_GLYPH_FORMAT_BITMAP,
+ FT_GLYPH_FORMAT_OUTLINE, or FT_GLYPH_FORMAT_COMPOSITE, but
+ others are possible.''')
+
+ bitmap_top = property( lambda self:
+ self._FT_GlyphSlot.contents.bitmap_top,
+ doc = '''This is the bitmap's top bearing expressed in integer
+ pixels. Remember that this is the distance from the
+ baseline to the top-most glyph scanline, upwards y
+ coordinates being positive.''')
+
+ bitmap_left = property( lambda self:
+ self._FT_GlyphSlot.contents.bitmap_left,
+ doc = '''This is the bitmap's left bearing expressed in integer
+ pixels. Of course, this is only valid if the format is
+ FT_GLYPH_FORMAT_BITMAP.''')
+
+ linearHoriAdvance = property( lambda self:
+ self._FT_GlyphSlot.contents.linearHoriAdvance,
+ doc = '''The advance width of the unhinted glyph. Its value
+ is expressed in 16.16 fractional pixels, unless
+ FT_LOAD_LINEAR_DESIGN is set when loading the glyph.
+ This field can be important to perform correct
+ WYSIWYG layout. Only relevant for outline glyphs.''')
+
+ linearVertAdvance = property( lambda self:
+ self._FT_GlyphSlot.contents.linearVertAdvance,
+ doc = '''The advance height of the unhinted glyph. Its value
+ is expressed in 16.16 fractional pixels, unless
+ FT_LOAD_LINEAR_DESIGN is set when loading the glyph.
+ This field can be important to perform correct
+ WYSIWYG layout. Only relevant for outline glyphs.''')
+
+
+# -----------------------------------------------------------------------------
+# Face wrapper
+# -----------------------------------------------------------------------------
+class Face( object ):
+ '''
+ FT_Face wrapper
+
+ FreeType root face class structure. A face object models a typeface in a
+ font file.
+ '''
+ def __init__( self, filename, index = 0 ):
+ '''
+ Build a new Face
+
+ :param str filename:
+ A path to the font file.
+
+ :param int index:
+ The index of the face within the font.
+ The first face has index 0.
+ '''
+ library = get_handle( )
+ face = FT_Face( )
+ self._FT_Face = None
+ #error = FT_New_Face( library, filename, 0, byref(face) )
+ self._filebodys = []
+ try:
+ u_filename = c_char_p(_encode_filename(filename))
+ error = FT_New_Face( library, u_filename, index, byref(face) )
+ except UnicodeError:
+ with open(filename, mode='rb') as f:
+ filebody = f.read()
+ error = FT_New_Memory_Face( library, filebody, len(filebody),
+ index, byref(face) )
+ self._filebodys.append(filebody) # prevent gc
+ if error: raise FT_Exception( error )
+ self._filename = filename
+ self._index = index
+ self._FT_Face = face
+
+ def __del__( self ):
+ '''
+ Discard face object, as well as all of its child slots and sizes.
+ '''
+ if self._FT_Face is not None:
+ FT_Done_Face( self._FT_Face )
+
+
+ def attach_file( self, filename ):
+ '''
+ Attach data to a face object. Normally, this is used to read
+ additional information for the face object. For example, you can attach
+ an AFM file that comes with a Type 1 font to get the kerning values and
+ other metrics.
+
+ :param filename: Filename to attach
+
+ **Note**
+
+ The meaning of the 'attach' (i.e., what really happens when the new
+ file is read) is not fixed by FreeType itself. It really depends on the
+ font format (and thus the font driver).
+
+ Client applications are expected to know what they are doing when
+ invoking this function. Most drivers simply do not implement file
+ attachments.
+ '''
+
+ try:
+ u_filename = c_char_p(_encode_filename(filename))
+ error = FT_Attach_File( self._FT_Face, u_filename )
+ except UnicodeError:
+ with open(filename, mode='rb') as f:
+ filebody = f.read()
+ parameters = FT_Open_Args()
+ parameters.flags = FT_OPEN_MEMORY
+ parameters.memory_base = filebody
+ parameters.memory_size = len(filebody)
+ parameters.stream = None
+ error = FT_Attach_Stream( self._FT_Face, parameters )
+ self._filebodys.append(filebody) # prevent gc
+ if error: raise FT_Exception( error)
+
+
+ def set_char_size( self, width=0, height=0, hres=72, vres=72 ):
+ '''
+ This function calls FT_Request_Size to request the nominal size (in
+ points).
+
+ :param float width: The nominal width, in 26.6 fractional points.
+
+ :param float height: The nominal height, in 26.6 fractional points.
+
+ :param float hres: The horizontal resolution in dpi.
+
+ :param float vres: The vertical resolution in dpi.
+
+ **Note**
+
+ If either the character width or height is zero, it is set equal to the
+ other value.
+
+ If either the horizontal or vertical resolution is zero, it is set
+ equal to the other value.
+
+ A character width or height smaller than 1pt is set to 1pt; if both
+ resolution values are zero, they are set to 72dpi.
+
+ Don't use this function if you are using the FreeType cache API.
+ '''
+ error = FT_Set_Char_Size( self._FT_Face, width, height, hres, vres )
+ if error: raise FT_Exception( error)
+
+ def set_pixel_sizes( self, width, height ):
+ '''
+ This function calls FT_Request_Size to request the nominal size (in
+ pixels).
+
+ :param width: The nominal width, in pixels.
+
+ :param height: The nominal height, in pixels.
+ '''
+ error = FT_Set_Pixel_Sizes( self._FT_Face, width, height )
+ if error: raise FT_Exception(error)
+
+ def select_charmap( self, encoding ):
+ '''
+ Select a given charmap by its encoding tag (as listed in 'freetype.h').
+
+ **Note**:
+
+ This function returns an error if no charmap in the face corresponds to
+ the encoding queried here.
+
+ Because many fonts contain more than a single cmap for Unicode
+ encoding, this function has some special code to select the one which
+ covers Unicode best ('best' in the sense that a UCS-4 cmap is preferred
+ to a UCS-2 cmap). It is thus preferable to FT_Set_Charmap in this case.
+ '''
+ error = FT_Select_Charmap( self._FT_Face, encoding )
+ if error: raise FT_Exception(error)
+
+ def set_charmap( self, charmap ):
+ '''
+ Select a given charmap for character code to glyph index mapping.
+
+ :param charmap: A handle to the selected charmap.
+ '''
+ error = FT_Set_Charmap( self._FT_Face, charmap._FT_Charmap )
+ if error : raise FT_Exception(error)
+
+ def get_char_index( self, charcode ):
+ '''
+ Return the glyph index of a given character code. This function uses a
+ charmap object to do the mapping.
+
+ :param charcode: The character code.
+
+ **Note**:
+
+ If you use FreeType to manipulate the contents of font files directly,
+ be aware that the glyph index returned by this function doesn't always
+ correspond to the internal indices used within the file. This is done
+ to ensure that value 0 always corresponds to the 'missing glyph'.
+ '''
+ if isinstance(charcode, (str,unicode)):
+ charcode = ord(charcode)
+ return FT_Get_Char_Index( self._FT_Face, charcode )
+
+ def get_first_char( self ):
+ '''
+ This function is used to return the first character code in the current
+ charmap of a given face. It also returns the corresponding glyph index.
+
+ :return: Glyph index of first character code. 0 if charmap is empty.
+
+ **Note**:
+
+ You should use this function with get_next_char to be able to parse
+ all character codes available in a given charmap. The code should look
+ like this:
+
+ Note that 'agindex' is set to 0 if the charmap is empty. The result
+ itself can be 0 in two cases: if the charmap is empty or if the value 0
+ is the first valid character code.
+ '''
+ agindex = FT_UInt()
+ charcode = FT_Get_First_Char( self._FT_Face, byref(agindex) )
+ return charcode, agindex.value
+
+ def get_next_char( self, charcode, agindex ):
+ '''
+ This function is used to return the next character code in the current
+ charmap of a given face following the value 'charcode', as well as the
+ corresponding glyph index.
+
+ :param charcode: The starting character code.
+
+ :param agindex: Glyph index of next character code. 0 if charmap is empty.
+
+ **Note**:
+
+ You should use this function with FT_Get_First_Char to walk over all
+ character codes available in a given charmap. See the note for this
+ function for a simple code example.
+
+ Note that 'agindex' is set to 0 when there are no more codes in the
+ charmap.
+ '''
+ agindex = FT_UInt( 0 ) #agindex )
+ charcode = FT_Get_Next_Char( self._FT_Face, charcode, byref(agindex) )
+ return charcode, agindex.value
+
+ def get_name_index( self, name ):
+ '''
+ Return the glyph index of a given glyph name. This function uses driver
+ specific objects to do the translation.
+
+ :param name: The glyph name.
+ '''
+ return FT_Get_Name_Index( self._FT_Face, name )
+
+ def set_transform( self, matrix, delta ):
+ '''
+ A function used to set the transformation that is applied to glyph
+ images when they are loaded into a glyph slot through FT_Load_Glyph.
+
+ :param matrix: A pointer to the transformation's 2x2 matrix.
+ Use 0 for the identity matrix.
+
+ :parm delta: A pointer to the translation vector.
+ Use 0 for the null vector.
+
+ **Note**:
+
+ The transformation is only applied to scalable image formats after the
+ glyph has been loaded. It means that hinting is unaltered by the
+ transformation and is performed on the character size given in the last
+ call to FT_Set_Char_Size or FT_Set_Pixel_Sizes.
+
+ Note that this also transforms the 'face.glyph.advance' field, but
+ not the values in 'face.glyph.metrics'.
+ '''
+ FT_Set_Transform( self._FT_Face,
+ byref(matrix), byref(delta) )
+
+ def select_size( self, strike_index ):
+ '''
+ Select a bitmap strike.
+
+ :param strike_index: The index of the bitmap strike in the
+ 'available_sizes' field of Face object.
+ '''
+ error = FT_Select_Size( self._FT_Face, strike_index )
+ if error: raise FT_Exception( error )
+
+ def load_glyph( self, index, flags = FT_LOAD_RENDER ):
+ '''
+ A function used to load a single glyph into the glyph slot of a face
+ object.
+
+ :param index: The index of the glyph in the font file. For CID-keyed
+ fonts (either in PS or in CFF format) this argument
+ specifies the CID value.
+
+ :param flags: A flag indicating what to load for this glyph. The FT_LOAD_XXX
+ constants can be used to control the glyph loading process
+ (e.g., whether the outline should be scaled, whether to load
+ bitmaps or not, whether to hint the outline, etc).
+
+ **Note**:
+
+ The loaded glyph may be transformed. See FT_Set_Transform for the
+ details.
+
+ For subsetted CID-keyed fonts, 'FT_Err_Invalid_Argument' is returned
+ for invalid CID values (this is, for CID values which don't have a
+ corresponding glyph in the font). See the discussion of the
+ FT_FACE_FLAG_CID_KEYED flag for more details.
+ '''
+ error = FT_Load_Glyph( self._FT_Face, index, flags )
+ if error: raise FT_Exception( error )
+
+ def load_char( self, char, flags = FT_LOAD_RENDER ):
+ '''
+ A function used to load a single glyph into the glyph slot of a face
+ object, according to its character code.
+
+ :param char: The glyph's character code, according to the current
+ charmap used in the face.
+
+ :param flags: A flag indicating what to load for this glyph. The
+ FT_LOAD_XXX constants can be used to control the glyph
+ loading process (e.g., whether the outline should be
+ scaled, whether to load bitmaps or not, whether to hint
+ the outline, etc).
+
+ **Note**:
+
+ This function simply calls FT_Get_Char_Index and FT_Load_Glyph.
+ '''
+
+ if len(char) == 1:
+ char = ord(char)
+ error = FT_Load_Char( self._FT_Face, char, flags )
+ if error: raise FT_Exception( error )
+
+
+ def get_advance( self, gindex, flags ):
+ '''
+ Retrieve the advance value of a given glyph outline in an FT_Face. By
+ default, the unhinted advance is returned in font units.
+
+ :param gindex: The glyph index.
+
+ :param flags: A set of bit flags similar to those used when calling
+ FT_Load_Glyph, used to determine what kind of advances
+ you need.
+
+ :return: The advance value, in either font units or 16.16 format.
+
+ If FT_LOAD_VERTICAL_LAYOUT is set, this is the vertical
+ advance corresponding to a vertical layout. Otherwise, it is
+ the horizontal advance in a horizontal layout.
+ '''
+
+ padvance = FT_Fixed(0)
+ error = FT_Get_Advance( self._FT_Face, gindex, flags, byref(padvance) )
+ if error: raise FT_Exception( error )
+ return padvance.value
+
+
+
+ def get_kerning( self, left, right, mode = FT_KERNING_DEFAULT ):
+ '''
+ Return the kerning vector between two glyphs of a same face.
+
+ :param left: The index of the left glyph in the kern pair.
+
+ :param right: The index of the right glyph in the kern pair.
+
+ :param mode: See FT_Kerning_Mode for more information. Determines the scale
+ and dimension of the returned kerning vector.
+
+ **Note**:
+
+ Only horizontal layouts (left-to-right & right-to-left) are supported
+ by this method. Other layouts, or more sophisticated kernings, are out
+ of the scope of this API function -- they can be implemented through
+ format-specific interfaces.
+ '''
+ left_glyph = self.get_char_index( left )
+ right_glyph = self.get_char_index( right )
+ kerning = FT_Vector(0,0)
+ error = FT_Get_Kerning( self._FT_Face,
+ left_glyph, right_glyph, mode, byref(kerning) )
+ if error: raise FT_Exception( error )
+ return kerning
+
+ def get_format(self):
+ '''
+ Return a string describing the format of a given face, using values
+ which can be used as an X11 FONT_PROPERTY. Possible values are
+ 'TrueType', 'Type 1', 'BDF', ‘PCF', ‘Type 42', ‘CID Type 1', ‘CFF',
+ 'PFR', and ‘Windows FNT'.
+ '''
+
+ return FT_Get_X11_Font_Format( self._FT_Face )
+
+
+ def get_fstype(self):
+ '''
+ Return the fsType flags for a font (embedding permissions).
+
+ The return value is a tuple containing the freetype enum name
+ as a string and the actual flag as an int
+ '''
+
+ flag = FT_Get_FSType_Flags( self._FT_Face )
+ for k, v in FT_FSTYPE_XXX.items():
+ if v == flag:
+ return k, v
+
+
+ def _get_sfnt_name_count(self):
+ return FT_Get_Sfnt_Name_Count( self._FT_Face )
+ sfnt_name_count = property(_get_sfnt_name_count,
+ doc = '''Number of name strings in the SFNT 'name' table.''')
+
+ def get_sfnt_name( self, index ):
+ '''
+ Retrieve a string of the SFNT 'name' table for a given index
+
+ :param index: The index of the 'name' string.
+
+ **Note**:
+
+ The 'string' array returned in the 'aname' structure is not
+ null-terminated. The application should deallocate it if it is no
+ longer in use.
+
+ Use FT_Get_Sfnt_Name_Count to get the total number of available
+ 'name' table entries, then do a loop until you get the right
+ platform, encoding, and name ID.
+ '''
+ name = FT_SfntName( )
+ error = FT_Get_Sfnt_Name( self._FT_Face, index, byref(name) )
+ if error: raise FT_Exception( error )
+ return SfntName( name )
+
+ def _get_postscript_name( self ):
+ return FT_Get_Postscript_Name( self._FT_Face )
+ postscript_name = property( _get_postscript_name,
+ doc = '''ASCII PostScript name of face, if available. This only
+ works with PostScript and TrueType fonts.''')
+
+ def _has_horizontal( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_HORIZONTAL )
+ has_horizontal = property( _has_horizontal,
+ doc = '''True whenever a face object contains horizontal metrics
+ (this is true for all font formats though).''')
+
+ def _has_vertical( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_VERTICAL )
+ has_vertical = property( _has_vertical,
+ doc = '''True whenever a face object contains vertical metrics.''')
+
+ def _has_kerning( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_KERNING )
+ has_kerning = property( _has_kerning,
+ doc = '''True whenever a face object contains kerning data that can
+ be accessed with FT_Get_Kerning.''')
+
+ def _is_scalable( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_SCALABLE )
+ is_scalable = property( _is_scalable,
+ doc = '''true whenever a face object contains a scalable font face
+ (true for TrueType, Type 1, Type 42, CID, OpenType/CFF,
+ and PFR font formats.''')
+
+ def _is_sfnt( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_SFNT )
+ is_sfnt = property( _is_sfnt,
+ doc = '''true whenever a face object contains a font whose format is
+ based on the SFNT storage scheme. This usually means: TrueType
+ fonts, OpenType fonts, as well as SFNT-based embedded bitmap
+ fonts.
+
+ If this macro is true, all functions defined in
+ FT_SFNT_NAMES_H and FT_TRUETYPE_TABLES_H are available.''')
+
+ def _is_fixed_width( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_FIXED_WIDTH )
+ is_fixed_width = property( _is_fixed_width,
+ doc = '''True whenever a face object contains a font face that
+ contains fixed-width (or 'monospace', 'fixed-pitch',
+ etc.) glyphs.''')
+
+ def _has_fixed_sizes( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_FIXED_SIZES )
+ has_fixed_sizes = property( _has_fixed_sizes,
+ doc = '''True whenever a face object contains some embedded
+ bitmaps. See the 'available_sizes' field of the FT_FaceRec
+ structure.''')
+
+ def _has_glyph_names( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_GLYPH_NAMES )
+ has_glyph_names = property( _has_glyph_names,
+ doc = '''True whenever a face object contains some glyph names
+ that can be accessed through FT_Get_Glyph_Name.''')
+
+ def _has_multiple_masters( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS )
+ has_multiple_masters = property( _has_multiple_masters,
+ doc = '''True whenever a face object contains some
+ multiple masters. The functions provided by
+ FT_MULTIPLE_MASTERS_H are then available to
+ choose the exact design you want.''')
+
+ def _is_cid_keyed( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_CID_KEYED )
+ is_cid_keyed = property( _is_cid_keyed,
+ doc = '''True whenever a face object contains a CID-keyed
+ font. See the discussion of FT_FACE_FLAG_CID_KEYED for
+ more details.
+
+ If this macro is true, all functions defined in FT_CID_H
+ are available.''')
+
+ def _is_tricky( self ):
+ return bool( self.face_flags & FT_FACE_FLAG_TRICKY )
+ is_tricky = property( _is_tricky,
+ doc = '''True whenever a face represents a 'tricky' font. See the
+ discussion of FT_FACE_FLAG_TRICKY for more details.''')
+
+
+ num_faces = property(lambda self: self._FT_Face.contents.num_faces,
+ doc = '''The number of faces in the font file. Some font formats can
+ have multiple faces in a font file.''')
+
+ face_index = property(lambda self: self._FT_Face.contents.face_index,
+ doc = '''The index of the face in the font file. It is set to 0 if
+ there is only one face in the font file.''')
+
+ face_flags = property(lambda self: self._FT_Face.contents.face_flags,
+ doc = '''A set of bit flags that give important information about
+ the face; see FT_FACE_FLAG_XXX for the details.''')
+
+ style_flags = property(lambda self: self._FT_Face.contents.style_flags,
+ doc = '''A set of bit flags indicating the style of the face; see
+ FT_STYLE_FLAG_XXX for the details.''')
+
+ num_glyphs = property(lambda self: self._FT_Face.contents.num_glyphs,
+ doc = '''The number of glyphs in the face. If the face is scalable
+ and has sbits (see 'num_fixed_sizes'), it is set to the number of
+ outline glyphs.
+
+ For CID-keyed fonts, this value gives the highest CID used in the
+ font.''')
+
+ family_name = property(lambda self: self._FT_Face.contents.family_name,
+ doc = '''The face's family name. This is an ASCII string, usually
+ in English, which describes the typeface's family (like
+ 'Times New Roman', 'Bodoni', 'Garamond', etc). This is a
+ least common denominator used to list fonts. Some formats
+ (TrueType & OpenType) provide localized and Unicode
+ versions of this string. Applications should use the
+ format specific interface to access them. Can be NULL
+ (e.g., in fonts embedded in a PDF file).''')
+
+ style_name = property(lambda self: self._FT_Face.contents.style_name,
+ doc = '''The face's style name. This is an ASCII string, usually in
+ English, which describes the typeface's style (like
+ 'Italic', 'Bold', 'Condensed', etc). Not all font formats
+ provide a style name, so this field is optional, and can be
+ set to NULL. As for 'family_name', some formats provide
+ localized and Unicode versions of this string. Applications
+ should use the format specific interface to access them.''')
+
+ num_fixed_sizes = property(lambda self: self._FT_Face.contents.num_fixed_sizes,
+ doc = '''The number of bitmap strikes in the face. Even if the
+ face is scalable, there might still be bitmap strikes,
+ which are called 'sbits' in that case.''')
+
+ def _get_available_sizes( self ):
+ sizes = []
+ n = self.num_fixed_sizes
+ FT_sizes = self._FT_Face.contents.available_sizes
+ for i in range(n):
+ sizes.append( BitmapSize(FT_sizes[i]) )
+ return sizes
+ available_sizes = property(_get_available_sizes,
+ doc = '''A list of FT_Bitmap_Size for all bitmap strikes in the
+ face. It is set to NULL if there is no bitmap strike.''')
+
+ num_charmaps = property(lambda self: self._FT_Face.contents.num_charmaps)
+ def _get_charmaps( self ):
+ charmaps = []
+ n = self._FT_Face.contents.num_charmaps
+ FT_charmaps = self._FT_Face.contents.charmaps
+ for i in range(n):
+ charmaps.append( Charmap(FT_charmaps[i]) )
+ return charmaps
+ charmaps = property(_get_charmaps,
+ doc = '''A list of the charmaps of the face.''')
+
+ # ('generic', FT_Generic),
+
+ def _get_bbox( self ):
+ return BBox( self._FT_Face.contents.bbox )
+ bbox = property( _get_bbox,
+ doc = '''The font bounding box. Coordinates are expressed in font units
+ (see 'units_per_EM'). The box is large enough to contain any
+ glyph from the font. Thus, 'bbox.yMax' can be seen as the
+ 'maximal ascender', and 'bbox.yMin' as the 'minimal
+ descender'. Only relevant for scalable formats.
+
+ Note that the bounding box might be off by (at least) one pixel
+ for hinted fonts. See FT_Size_Metrics for further discussion.''')
+
+ units_per_EM = property(lambda self: self._FT_Face.contents.units_per_EM,
+ doc = '''The number of font units per EM square for this
+ face. This is typically 2048 for TrueType fonts, and 1000
+ for Type 1 fonts. Only relevant for scalable formats.''')
+
+ ascender = property(lambda self: self._FT_Face.contents.ascender,
+ doc = '''The typographic ascender of the face, expressed in font
+ units. For font formats not having this information, it is
+ set to 'bbox.yMax'. Only relevant for scalable formats.''')
+
+ descender = property(lambda self: self._FT_Face.contents.descender,
+ doc = '''The typographic descender of the face, expressed in font
+ units. For font formats not having this information, it is
+ set to 'bbox.yMin'. Note that this field is usually
+ negative. Only relevant for scalable formats.''')
+
+ height = property(lambda self: self._FT_Face.contents.height,
+ doc = '''The height is the vertical distance between two consecutive
+ baselines, expressed in font units. It is always positive. Only
+ relevant for scalable formats.''')
+
+ max_advance_width = property(lambda self: self._FT_Face.contents.max_advance_width,
+ doc = '''The maximal advance width, in font units, for all
+ glyphs in this face. This can be used to make word
+ wrapping computations faster. Only relevant for
+ scalable formats.''')
+
+ max_advance_height = property(lambda self: self._FT_Face.contents.max_advance_height,
+ doc = '''The maximal advance height, in font units, for all
+ glyphs in this face. This is only relevant for
+ vertical layouts, and is set to 'height' for fonts
+ that do not provide vertical metrics. Only relevant
+ for scalable formats.''')
+
+ underline_position = property(lambda self: self._FT_Face.contents.underline_position,
+ doc = '''The position, in font units, of the underline line
+ for this face. It is the center of the underlining
+ stem. Only relevant for scalable formats.''')
+
+ underline_thickness = property(lambda self: self._FT_Face.contents.underline_thickness,
+ doc = '''The thickness, in font units, of the underline for
+ this face. Only relevant for scalable formats.''')
+
+
+ def _get_glyph( self ):
+ return GlyphSlot( self._FT_Face.contents.glyph )
+ glyph = property( _get_glyph,
+ doc = '''The face's associated glyph slot(s).''')
+
+ def _get_size( self ):
+ size = self._FT_Face.contents.size
+ metrics = size.contents.metrics
+ return SizeMetrics(metrics)
+ size = property( _get_size,
+ doc = '''The current active size for this face.''')
+
+ def _get_charmap( self ):
+ return Charmap( self._FT_Face.contents.charmap)
+ charmap = property( _get_charmap,
+ doc = '''The current active charmap for this face.''')
+
+
+
+# -----------------------------------------------------------------------------
+# SfntName wrapper
+# -----------------------------------------------------------------------------
+class SfntName( object ):
+ '''
+ SfntName wrapper
+
+ A structure used to model an SFNT 'name' table entry.
+ '''
+ def __init__(self, name):
+ '''
+ Create a new SfntName object.
+
+ :param name : SFNT 'name' table entry.
+
+ '''
+ self._FT_SfntName = name
+
+ platform_id = property(lambda self: self._FT_SfntName.platform_id,
+ doc = '''The platform ID for 'string'.''')
+
+ encoding_id = property(lambda self: self._FT_SfntName.encoding_id,
+ doc = '''The encoding ID for 'string'.''')
+
+ language_id = property(lambda self: self._FT_SfntName.language_id,
+ doc = '''The language ID for 'string'.''')
+
+ name_id = property(lambda self: self._FT_SfntName.name_id,
+ doc = '''An identifier for 'string'.''')
+
+ #string = property(lambda self: self._FT_SfntName.string)
+
+ string_len = property(lambda self: self._FT_SfntName.string_len,
+ doc = '''The length of 'string' in bytes.''')
+
+ def _get_string(self):
+ # #s = self._FT_SfntName
+ s = string_at(self._FT_SfntName.string, self._FT_SfntName.string_len)
+ return s
+ # #return s.decode('utf-16be', 'ignore')
+ # return s.decode('utf-8', 'ignore')
+ # #n = s.string_len
+ # #data = [s.string[i] for i in range(n)]
+ # #return data
+ string = property(_get_string,
+ doc = '''The 'name' string. Note that its format differs depending on
+ the (platform,encoding) pair. It can be a Pascal String, a
+ UTF-16 one, etc.
+
+ Generally speaking, the string is not zero-terminated. Please
+ refer to the TrueType specification for details.''')
+
+
+
+# -----------------------------------------------------------------------------
+class Stroker( object ):
+ '''
+ FT_Stroker wrapper
+
+ This component generates stroked outlines of a given vectorial glyph. It
+ also allows you to retrieve the 'outside' and/or the 'inside' borders of
+ the stroke.
+
+ This can be useful to generate 'bordered' glyph, i.e., glyphs displayed
+ with a coloured (and anti-aliased) border around their shape.
+ '''
+
+ def __init__( self ):
+ '''
+ Create a new Stroker object.
+ '''
+ library = get_handle( )
+ stroker = FT_Stroker( )
+ error = FT_Stroker_New( library, byref(stroker) )
+ if error: raise FT_Exception( error )
+ self._FT_Stroker = stroker
+
+
+ def __del__( self ):
+ '''
+ Destroy object.
+ '''
+ FT_Stroker_Done( self._FT_Stroker )
+
+
+ def set( self, radius, line_cap, line_join, miter_limit ):
+ '''
+ Reset a stroker object's attributes.
+
+ :param radius: The border radius.
+
+ :param line_cap: The line cap style.
+
+ :param line_join: The line join style.
+
+ :param miter_limit: The miter limit for the FT_STROKER_LINEJOIN_MITER
+ style, expressed as 16.16 fixed point value.
+
+ **Note**:
+
+ The radius is expressed in the same units as the outline coordinates.
+ '''
+ FT_Stroker_Set( self._FT_Stroker,
+ radius, line_cap, line_join, miter_limit )
+
+
+ def rewind( self ):
+ '''
+ Reset a stroker object without changing its attributes. You should call
+ this function before beginning a new series of calls to
+ FT_Stroker_BeginSubPath or FT_Stroker_EndSubPath.
+ '''
+ FT_Stroker_Rewind( self._FT_Stroker )
+
+
+ def parse_outline( self, outline, opened ):
+ '''
+ A convenience function used to parse a whole outline with the
+ stroker. The resulting outline(s) can be retrieved later by functions
+ like FT_Stroker_GetCounts and FT_Stroker_Export.
+
+ :param outline: The source outline.
+
+ :pram opened: A boolean. If 1, the outline is treated as an open path
+ instead of a closed one.
+
+ **Note**:
+
+ If 'opened' is 0 (the default), the outline is treated as a closed
+ path, and the stroker generates two distinct 'border' outlines.
+
+ If 'opened' is 1, the outline is processed as an open path, and the
+ stroker generates a single 'stroke' outline.
+
+ This function calls 'rewind' automatically.
+ '''
+ error = FT_Stroker_ParseOutline( self._FT_Stroker, outline, opened)
+ if error: raise FT_Exception( error )
+
+
+ def begin_subpath( self, to, _open ):
+ '''
+ Start a new sub-path in the stroker.
+
+ :param to A pointer to the start vector.
+
+ :param _open: A boolean. If 1, the sub-path is treated as an open one.
+
+ **Note**:
+
+ This function is useful when you need to stroke a path that is not
+ stored as an 'Outline' object.
+ '''
+ error = FT_Stroker_BeginSubPath( self._FT_Stroker, to, _open )
+ if error: raise FT_Exception( error )
+
+
+ def end_subpath( self ):
+ '''
+ Close the current sub-path in the stroker.
+
+ **Note**:
+
+ You should call this function after 'begin_subpath'. If the subpath
+ was not 'opened', this function 'draws' a single line segment to the
+ start position when needed.
+ '''
+ error = FT_Stroker_EndSubPath( self._FT_Stroker)
+ if error: raise FT_Exception( error )
+
+
+ def line_to( self, to ):
+ '''
+ 'Draw' a single line segment in the stroker's current sub-path, from
+ the last position.
+
+ :param to: A pointer to the destination point.
+
+ **Note**:
+
+ You should call this function between 'begin_subpath' and
+ 'end_subpath'.
+ '''
+ error = FT_Stroker_LineTo( self._FT_Stroker, to )
+ if error: raise FT_Exception( error )
+
+
+ def conic_to( self, control, to ):
+ '''
+ 'Draw' a single quadratic Bezier in the stroker's current sub-path,
+ from the last position.
+
+ :param control: A pointer to a Bezier control point.
+
+ :param to: A pointer to the destination point.
+
+ **Note**:
+
+ You should call this function between 'begin_subpath' and
+ 'end_subpath'.
+ '''
+ error = FT_Stroker_ConicTo( self._FT_Stroker, control, to )
+ if error: raise FT_Exception( error )
+
+
+ def cubic_to( self, control1, control2, to ):
+ '''
+ 'Draw' a single quadratic Bezier in the stroker's current sub-path,
+ from the last position.
+
+ :param control1: A pointer to the first Bezier control point.
+
+ :param control2: A pointer to second Bezier control point.
+
+ :param to: A pointer to the destination point.
+
+ **Note**:
+
+ You should call this function between 'begin_subpath' and
+ 'end_subpath'.
+ '''
+ error = FT_Stroker_CubicTo( self._FT_Stroker, control1, control2, to )
+ if error: raise FT_Exception( error )
+
+
+ def get_border_counts( self, border ):
+ '''
+ Call this function once you have finished parsing your paths with the
+ stroker. It returns the number of points and contours necessary to
+ export one of the 'border' or 'stroke' outlines generated by the
+ stroker.
+
+ :param border: The border index.
+
+ :return: number of points, number of contours
+ '''
+ anum_points = FT_UInt()
+ anum_contours = FT_UInt()
+ error = FT_Stroker_GetBorderCounts( self._FT_Stroker, border,
+ byref(anum_points), byref(anum_contours) )
+ if error: raise FT_Exception( error )
+ return anum_points.value, anum_contours.value
+
+
+ def export_border( self , border, outline ):
+ '''
+ Call this function after 'get_border_counts' to export the
+ corresponding border to your own 'Outline' structure.
+
+ Note that this function appends the border points and contours to your
+ outline, but does not try to resize its arrays.
+
+ :param border: The border index.
+
+ :param outline: The target outline.
+
+ **Note**:
+
+ Always call this function after get_border_counts to get sure that
+ there is enough room in your 'Outline' object to receive all new
+ data.
+
+ When an outline, or a sub-path, is 'closed', the stroker generates two
+ independent 'border' outlines, named 'left' and 'right'
+
+ When the outline, or a sub-path, is 'opened', the stroker merges the
+ 'border' outlines with caps. The 'left' border receives all points,
+ while the 'right' border becomes empty.
+
+ Use the function export instead if you want to retrieve all borders
+ at once.
+ '''
+ FT_Stroker_ExportBorder( self._FT_Stroker, border, outline._FT_Outline )
+
+
+ def get_counts( self ):
+ '''
+ Call this function once you have finished parsing your paths with the
+ stroker. It returns the number of points and contours necessary to
+ export all points/borders from the stroked outline/path.
+
+ :return: number of points, number of contours
+ '''
+
+ anum_points = FT_UInt()
+ anum_contours = FT_UInt()
+ error = FT_Stroker_GetCounts( self._FT_Stroker,
+ byref(anum_points), byref(anum_contours) )
+ if error: raise FT_Exception( error )
+ return anum_points.value, anum_contours.value
+
+
+ def export( self, outline ):
+ '''
+ Call this function after get_border_counts to export all borders to
+ your own 'Outline' structure.
+
+ Note that this function appends the border points and contours to your
+ outline, but does not try to resize its arrays.
+
+ :param outline: The target outline.
+ '''
+ FT_Stroker_Export( self._FT_Stroker, outline._FT_Outline )
diff --git a/third_party/freetype-py/freetype/ft_enums/__init__.py b/third_party/freetype-py/freetype/ft_enums/__init__.py
new file mode 100644
index 0000000..ac22a96
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/__init__.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+'''
+Freetype enum types
+-------------------
+
+FT_PIXEL_MODES: An enumeration type used to describe the format of pixels in a
+ given bitmap. Note that additional formats may be added in the
+ future.
+
+FT_GLYPH_BBOX_MODES: The mode how the values of FT_Glyph_Get_CBox are returned.
+
+FT_GLYPH_FORMATS: An enumeration type used to describe the format of a given
+ glyph image. Note that this version of FreeType only supports
+ two image formats, even though future font drivers will be
+ able to register their own format.
+
+FT_ENCODINGS: An enumeration used to specify character sets supported by
+ charmaps. Used in the FT_Select_Charmap API function.
+
+FT_RENDER_MODES: An enumeration type that lists the render modes supported by
+ FreeType 2. Each mode corresponds to a specific type of
+ scanline conversion performed on the outline.
+
+FT_LOAD_TARGETS: A list of values that are used to select a specific hinting
+ algorithm to use by the hinter. You should OR one of these
+ values to your 'load_flags' when calling FT_Load_Glyph.
+
+FT_LOAD_FLAGS: A list of bit-field constants used with FT_Load_Glyph to
+ indicate what kind of operations to perform during glyph
+ loading.
+
+FT_STYLE_FLAGS: A list of bit-flags used to indicate the style of a given
+ face. These are used in the 'style_flags' field of FT_FaceRec.
+
+FT_FSTYPES: A list of bit flags that inform client applications of embedding
+ and subsetting restrictions associated with a font.
+
+FT_FACE_FLAGS: A list of bit flags used in the 'face_flags' field of the
+ FT_FaceRec structure. They inform client applications of
+ properties of the corresponding face.
+
+FT_OUTLINE_FLAGS: A list of bit-field constants use for the flags in an
+ outline's 'flags' field.
+
+FT_OPEN_MODES: A list of bit-field constants used within the 'flags' field of
+ the FT_Open_Args structure.
+
+FT_KERNING_MODES: An enumeration used to specify which kerning values to return
+ in FT_Get_Kerning.
+
+FT_STROKER_LINEJOINS: These values determine how two joining lines are rendered
+ in a stroker.
+
+FT_STROKER_LINECAPS: These values determine how the end of opened sub-paths are
+ rendered in a stroke.
+
+FT_STROKER_BORDERS: These values are used to select a given stroke border in
+ FT_Stroker_GetBorderCounts and FT_Stroker_ExportBorder.
+
+FT_LCD_FILTERS: A list of values to identify various types of LCD filters.
+
+TT_PLATFORMS: A list of valid values for the 'platform_id' identifier code in
+ FT_CharMapRec and FT_SfntName structures.
+
+TT_APPLE_IDS: A list of valid values for the 'encoding_id' for
+ TT_PLATFORM_APPLE_UNICODE charmaps and name entries.
+
+TT_MAC_IDS: A list of valid values for the 'encoding_id' for
+ TT_PLATFORM_MACINTOSH charmaps and name entries.
+
+TT_MS_IDS: A list of valid values for the 'encoding_id' for
+ TT_PLATFORM_MICROSOFT charmaps and name entries.
+
+TT_ADOBE_IDS: A list of valid values for the 'encoding_id' for
+ TT_PLATFORM_ADOBE charmaps. This is a FreeType-specific
+ extension!
+
+TT_MAC_LANGIDS: Possible values of the language identifier field in the name
+ records of the TTF `name' table if the `platform' identifier
+ code is TT_PLATFORM_MACINTOSH.
+
+TT_MS_LANGIDS: Possible values of the language identifier field in the name
+ records of the TTF `name' table if the `platform' identifier
+ code is TT_PLATFORM_MICROSOFT.
+
+TT_NAME_IDS: Possible values of the `name' identifier field in the name
+ records of the TTF `name' table. These values are platform
+ independent.
+'''
+from freetype.ft_enums.ft_fstypes import *
+from freetype.ft_enums.ft_face_flags import *
+from freetype.ft_enums.ft_encodings import *
+from freetype.ft_enums.ft_glyph_bbox_modes import *
+from freetype.ft_enums.ft_glyph_formats import *
+from freetype.ft_enums.ft_kerning_modes import *
+from freetype.ft_enums.ft_lcd_filters import *
+from freetype.ft_enums.ft_load_flags import *
+from freetype.ft_enums.ft_load_targets import *
+from freetype.ft_enums.ft_open_modes import *
+from freetype.ft_enums.ft_outline_flags import *
+from freetype.ft_enums.ft_pixel_modes import *
+from freetype.ft_enums.ft_render_modes import *
+from freetype.ft_enums.ft_stroker_borders import *
+from freetype.ft_enums.ft_stroker_linecaps import *
+from freetype.ft_enums.ft_stroker_linejoins import *
+from freetype.ft_enums.ft_style_flags import *
+from freetype.ft_enums.tt_adobe_ids import *
+from freetype.ft_enums.tt_apple_ids import *
+from freetype.ft_enums.tt_mac_ids import *
+from freetype.ft_enums.tt_ms_ids import *
+from freetype.ft_enums.tt_ms_langids import *
+from freetype.ft_enums.tt_mac_langids import *
+from freetype.ft_enums.tt_name_ids import *
+from freetype.ft_enums.tt_platforms import *
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_encodings.py b/third_party/freetype-py/freetype/ft_enums/ft_encodings.py
new file mode 100644
index 0000000..8c5db6b
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_encodings.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+An enumeration used to specify character sets supported by charmaps. Used in
+the FT_Select_Charmap API function.
+
+FT_ENCODING_NONE
+
+ The encoding value 0 is reserved.
+
+FT_ENCODING_UNICODE
+
+ Corresponds to the Unicode character set. This value covers all versions of
+ the Unicode repertoire, including ASCII and Latin-1. Most fonts include a
+ Unicode charmap, but not all of them.
+
+ For example, if you want to access Unicode value U+1F028 (and the font
+ contains it), use value 0x1F028 as the input value for FT_Get_Char_Index.
+
+FT_ENCODING_MS_SYMBOL
+
+ Corresponds to the Microsoft Symbol encoding, used to encode mathematical
+ symbols in the 32..255 character code range. For more information, see
+ 'http://www.ceviz.net/symbol.htm'.
+
+FT_ENCODING_SJIS
+
+ Corresponds to Japanese SJIS encoding. More info at at
+ 'http://langsupport.japanreference.com/encoding.shtml'. See note on
+ multi-byte encodings below.
+
+FT_ENCODING_GB2312
+
+ Corresponds to an encoding system for Simplified Chinese as used used in
+ mainland China.
+
+FT_ENCODING_BIG5
+
+ Corresponds to an encoding system for Traditional Chinese as used in Taiwan
+ and Hong Kong.
+
+FT_ENCODING_WANSUNG
+
+ Corresponds to the Korean encoding system known as Wansung. For more
+ information see 'http://www.microsoft.com/typography/unicode/949.txt'.
+
+FT_ENCODING_JOHAB
+
+ The Korean standard character set (KS C 5601-1992), which corresponds to MS
+ Windows code page 1361. This character set includes all possible Hangeul
+ character combinations.
+
+FT_ENCODING_ADOBE_LATIN_1
+
+ Corresponds to a Latin-1 encoding as defined in a Type 1 PostScript font. It
+ is limited to 256 character codes.
+
+FT_ENCODING_ADOBE_STANDARD
+
+ Corresponds to the Adobe Standard encoding, as found in Type 1, CFF, and
+ OpenType/CFF fonts. It is limited to 256 character codes.
+
+FT_ENCODING_ADOBE_EXPERT
+
+ Corresponds to the Adobe Expert encoding, as found in Type 1, CFF, and
+ OpenType/CFF fonts. It is limited to 256 character codes.
+
+FT_ENCODING_ADOBE_CUSTOM
+
+ Corresponds to a custom encoding, as found in Type 1, CFF, and OpenType/CFF
+ fonts. It is limited to 256 character codes.
+
+FT_ENCODING_APPLE_ROMAN
+
+ Corresponds to the 8-bit Apple roman encoding. Many TrueType and OpenType
+ fonts contain a charmap for this encoding, since older versions of Mac OS are
+ able to use it.
+
+FT_ENCODING_OLD_LATIN_2
+
+ This value is deprecated and was never used nor reported by FreeType. Don't
+ use or test for it.
+"""
+
+def _FT_ENC_TAG(a,b,c,d):
+ return ( ord(a) << 24 | ord(b) << 16 | ord(c) << 8 | ord(d) )
+
+FT_ENCODINGS = {'FT_ENCODING_NONE' : _FT_ENC_TAG('\0','\0','\0','\0'),
+ 'FT_ENCODING_MS_SYMBOL' : _FT_ENC_TAG( 's','y','m','b' ),
+ 'FT_ENCODING_UNICODE' : _FT_ENC_TAG( 'u','n','i','c' ),
+ 'FT_ENCODING_SJIS' : _FT_ENC_TAG( 's','j','i','s' ),
+ 'FT_ENCODING_GB2312' : _FT_ENC_TAG( 'g','b',' ',' ' ),
+ 'FT_ENCODING_BIG5' : _FT_ENC_TAG( 'b','i','g','5' ),
+ 'FT_ENCODING_WANSUNG' : _FT_ENC_TAG( 'w','a','n','s' ),
+ 'FT_ENCODING_JOHAB' : _FT_ENC_TAG( 'j','o','h','a' ),
+ 'FT_ENCODING_ADOBE_STANDARD' : _FT_ENC_TAG( 'A','D','O','B' ),
+ 'FT_ENCODING_ADOBE_EXPERT' : _FT_ENC_TAG( 'A','D','B','E' ),
+ 'FT_ENCODING_ADOBE_CUSTOM' : _FT_ENC_TAG( 'A','D','B','C' ),
+ 'FT_ENCODING_ADOBE_LATIN1' : _FT_ENC_TAG( 'l','a','t','1' ),
+ 'FT_ENCODING_OLD_LATIN2' : _FT_ENC_TAG( 'l','a','t','2' ),
+ 'FT_ENCODING_APPLE_ROMAN' : _FT_ENC_TAG( 'a','r','m','n' ) }
+globals().update(FT_ENCODINGS)
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_face_flags.py b/third_party/freetype-py/freetype/ft_enums/ft_face_flags.py
new file mode 100644
index 0000000..4030437
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_face_flags.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of bit flags used in the 'face_flags' field of the FT_FaceRec
+structure. They inform client applications of properties of the corresponding
+face.
+
+
+FT_FACE_FLAG_SCALABLE
+
+ Indicates that the face contains outline glyphs. This doesn't prevent bitmap
+ strikes, i.e., a face can have both this and and FT_FACE_FLAG_FIXED_SIZES
+ set.
+
+
+FT_FACE_FLAG_FIXED_SIZES
+
+ Indicates that the face contains bitmap strikes. See also the
+ 'num_fixed_sizes' and 'available_sizes' fields of FT_FaceRec.
+
+
+FT_FACE_FLAG_FIXED_WIDTH
+
+ Indicates that the face contains fixed-width characters (like Courier,
+ Lucido, MonoType, etc.).
+
+
+FT_FACE_FLAG_SFNT
+
+ Indicates that the face uses the 'sfnt' storage scheme. For now, this means
+ TrueType and OpenType.
+
+
+FT_FACE_FLAG_HORIZONTAL
+
+ Indicates that the face contains horizontal glyph metrics. This should be set
+ for all common formats.
+
+
+FT_FACE_FLAG_VERTICAL
+
+ Indicates that the face contains vertical glyph metrics. This is only
+ available in some formats, not all of them.
+
+
+FT_FACE_FLAG_KERNING
+
+ Indicates that the face contains kerning information. If set, the kerning
+ distance can be retrieved through the function FT_Get_Kerning. Otherwise the
+ function always return the vector (0,0). Note that FreeType doesn't handle
+ kerning data from the 'GPOS' table (as present in some OpenType fonts).
+
+
+FT_FACE_FLAG_MULTIPLE_MASTERS
+
+ Indicates that the font contains multiple masters and is capable of
+ interpolating between them. See the multiple-masters specific API for
+ details.
+
+
+FT_FACE_FLAG_GLYPH_NAMES
+
+ Indicates that the font contains glyph names that can be retrieved through
+ FT_Get_Glyph_Name. Note that some TrueType fonts contain broken glyph name
+ tables. Use the function FT_Has_PS_Glyph_Names when needed.
+
+
+FT_FACE_FLAG_EXTERNAL_STREAM
+
+ Used internally by FreeType to indicate that a face's stream was provided by
+ the client application and should not be destroyed when FT_Done_Face is
+ called. Don't read or test this flag.
+
+
+FT_FACE_FLAG_HINTER
+
+ Set if the font driver has a hinting machine of its own. For example, with
+ TrueType fonts, it makes sense to use data from the SFNT 'gasp' table only if
+ the native TrueType hinting engine (with the bytecode interpreter) is
+ available and active.
+
+
+FT_FACE_FLAG_CID_KEYED
+
+ Set if the font is CID-keyed. In that case, the font is not accessed by glyph
+ indices but by CID values. For subsetted CID-keyed fonts this has the
+ consequence that not all index values are a valid argument to
+ FT_Load_Glyph. Only the CID values for which corresponding glyphs in the
+ subsetted font exist make FT_Load_Glyph return successfully; in all other
+ cases you get an 'FT_Err_Invalid_Argument' error.
+
+ Note that CID-keyed fonts which are in an SFNT wrapper don't have this flag
+ set since the glyphs are accessed in the normal way (using contiguous
+ indices); the 'CID-ness' isn't visible to the application.
+
+
+FT_FACE_FLAG_TRICKY
+
+ Set if the font is 'tricky', this is, it always needs the font format's
+ native hinting engine to get a reasonable result. A typical example is the
+ Chinese font 'mingli.ttf' which uses TrueType bytecode instructions to move
+ and scale all of its subglyphs.
+
+ It is not possible to autohint such fonts using FT_LOAD_FORCE_AUTOHINT; it
+ will also ignore FT_LOAD_NO_HINTING. You have to set both FT_LOAD_NO_HINTING
+ and FT_LOAD_NO_AUTOHINT to really disable hinting; however, you probably
+ never want this except for demonstration purposes.
+
+ Currently, there are six TrueType fonts in the list of tricky fonts; they are
+ hard-coded in file 'ttobjs.c'.
+"""
+FT_FACE_FLAGS = { 'FT_FACE_FLAG_SCALABLE' : 1 << 0,
+ 'FT_FACE_FLAG_FIXED_SIZES' : 1 << 1,
+ 'FT_FACE_FLAG_FIXED_WIDTH' : 1 << 2,
+ 'FT_FACE_FLAG_SFNT' : 1 << 3,
+ 'FT_FACE_FLAG_HORIZONTAL' : 1 << 4,
+ 'FT_FACE_FLAG_VERTICAL' : 1 << 5,
+ 'FT_FACE_FLAG_KERNING' : 1 << 6,
+ 'FT_FACE_FLAG_FAST_GLYPHS' : 1 << 7,
+ 'FT_FACE_FLAG_MULTIPLE_MASTERS' : 1 << 8,
+ 'FT_FACE_FLAG_GLYPH_NAMES' : 1 << 9,
+ 'FT_FACE_FLAG_EXTERNAL_STREAM' : 1 << 10,
+ 'FT_FACE_FLAG_HINTER' : 1 << 11,
+ 'FT_FACE_FLAG_CID_KEYED' : 1 << 12,
+ 'FT_FACE_FLAG_TRICKY' : 1 << 13
+}
+globals().update(FT_FACE_FLAGS)
+
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_fstypes.py b/third_party/freetype-py/freetype/ft_enums/ft_fstypes.py
new file mode 100644
index 0000000..4f4e2e0
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_fstypes.py
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of bit flags that inform client applications of embedding and
+subsetting restrictions associated with a font.
+
+FT_FSTYPE_INSTALLABLE_EMBEDDING
+
+ Fonts with no fsType bit set may be embedded and permanently installed on
+ the remote system by an application.
+
+
+FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING
+
+ Fonts that have only this bit set must not be modified, embedded or exchanged
+ in any manner without first obtaining permission of the font software
+ copyright owner.
+
+
+FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING
+
+ If this bit is set, the font may be embedded and temporarily loaded on the
+ remote system. Documents containing Preview & Print fonts must be opened
+ 'read-only'; no edits can be applied to the document.
+
+
+FT_FSTYPE_EDITABLE_EMBEDDING
+
+ If this bit is set, the font may be embedded but must only be installed
+ temporarily on other systems. In contrast to Preview & Print fonts,
+ documents containing editable fonts may be opened for reading, editing is
+ permitted, and changes may be saved.
+
+
+FT_FSTYPE_NO_SUBSETTING
+
+ If this bit is set, the font may not be subsetted prior to embedding.
+
+
+FT_FSTYPE_BITMAP_EMBEDDING_ONLY
+
+ If this bit is set, only bitmaps contained in the font may be embedded; no
+ outline data may be embedded. If there are no bitmaps available in the font,
+ then the font is unembeddable.
+"""
+
+FT_FSTYPES = {'FT_FSTYPE_INSTALLABLE_EMBEDDING' : 0x0000,
+ 'FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING' : 0x0002,
+ 'FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING' : 0x0004,
+ 'FT_FSTYPE_EDITABLE_EMBEDDING' : 0x0008,
+ 'FT_FSTYPE_NO_SUBSETTING' : 0x0100,
+ 'FT_FSTYPE_BITMAP_EMBEDDING_ONLY' : 0x0200,}
+globals().update(FT_FSTYPES)
+ft_fstype_installable_embedding = FT_FSTYPE_INSTALLABLE_EMBEDDING
+ft_fstype_restricted_license_embedding = FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING
+ft_fstype_preview_and_print_embedding = FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING
+ft_fstype_editable_embedding = FT_FSTYPE_EDITABLE_EMBEDDING
+ft_fstype_no_subsetting = FT_FSTYPE_NO_SUBSETTING
+ft_fstype_bitmap_embedding_only = FT_FSTYPE_BITMAP_EMBEDDING_ONLY
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_glyph_bbox_modes.py b/third_party/freetype-py/freetype/ft_enums/ft_glyph_bbox_modes.py
new file mode 100644
index 0000000..2de7bb7
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_glyph_bbox_modes.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+The mode how the values of FT_Glyph_Get_CBox are returned.
+
+FT_GLYPH_BBOX_UNSCALED
+
+ Return unscaled font units.
+
+FT_GLYPH_BBOX_SUBPIXELS
+
+ Return unfitted 26.6 coordinates.
+
+FT_GLYPH_BBOX_GRIDFIT
+
+ Return grid-fitted 26.6 coordinates.
+
+FT_GLYPH_BBOX_TRUNCATE
+
+ Return coordinates in integer pixels.
+
+FT_GLYPH_BBOX_PIXELS
+
+ Return grid-fitted pixel coordinates.
+"""
+FT_GLYPH_BBOX_MODES = {'FT_GLYPH_BBOX_UNSCALED' : 0,
+ 'FT_GLYPH_BBOX_SUBPIXELS' : 0,
+ 'FT_GLYPH_BBOX_GRIDFIT' : 1,
+ 'FT_GLYPH_BBOX_TRUNCATE' : 2,
+ 'FT_GLYPH_BBOX_PIXELS' : 3}
+globals().update(FT_GLYPH_BBOX_MODES)
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_glyph_formats.py b/third_party/freetype-py/freetype/ft_enums/ft_glyph_formats.py
new file mode 100644
index 0000000..8331719
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_glyph_formats.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+An enumeration type used to describe the format of a given glyph image. Note
+that this version of FreeType only supports two image formats, even though
+future font drivers will be able to register their own format.
+
+FT_GLYPH_FORMAT_NONE
+
+ The value 0 is reserved.
+
+FT_GLYPH_FORMAT_COMPOSITE
+
+ The glyph image is a composite of several other images. This format is only
+ used with FT_LOAD_NO_RECURSE, and is used to report compound glyphs (like
+ accented characters).
+
+FT_GLYPH_FORMAT_BITMAP
+
+ The glyph image is a bitmap, and can be described as an FT_Bitmap. You
+ generally need to access the 'bitmap' field of the FT_GlyphSlotRec structure
+ to read it.
+
+FT_GLYPH_FORMAT_OUTLINE
+
+ The glyph image is a vectorial outline made of line segments and Bezier arcs;
+ it can be described as an FT_Outline; you generally want to access the
+ 'outline' field of the FT_GlyphSlotRec structure to read it.
+
+FT_GLYPH_FORMAT_PLOTTER
+
+ The glyph image is a vectorial path with no inside and outside contours. Some
+ Type 1 fonts, like those in the Hershey family, contain glyphs in this
+ format. These are described as FT_Outline, but FreeType isn't currently
+ capable of rendering them correctly.
+"""
+
+def _FT_IMAGE_TAG(a,b,c,d):
+ return ( ord(a) << 24 | ord(b) << 16 | ord(c) << 8 | ord(d) )
+
+FT_GLYPH_FORMATS = {
+ 'FT_GLYPH_FORMAT_NONE' : _FT_IMAGE_TAG( '\0','\0','\0','\0' ),
+ 'FT_GLYPH_FORMAT_COMPOSITE' : _FT_IMAGE_TAG( 'c','o','m','p' ),
+ 'FT_GLYPH_FORMAT_BITMAP' : _FT_IMAGE_TAG( 'b','i','t','s' ),
+ 'FT_GLYPH_FORMAT_OUTLINE' : _FT_IMAGE_TAG( 'o','u','t','l' ),
+ 'FT_GLYPH_FORMAT_PLOTTER' : _FT_IMAGE_TAG( 'p','l','o','t' )}
+globals().update(FT_GLYPH_FORMATS)
+ft_glyph_format_none = FT_GLYPH_FORMAT_NONE
+ft_glyph_format_composite = FT_GLYPH_FORMAT_COMPOSITE
+ft_glyph_format_bitmap = FT_GLYPH_FORMAT_BITMAP
+ft_glyph_format_outline = FT_GLYPH_FORMAT_OUTLINE
+ft_glyph_format_plotter = FT_GLYPH_FORMAT_PLOTTER
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_kerning_modes.py b/third_party/freetype-py/freetype/ft_enums/ft_kerning_modes.py
new file mode 100644
index 0000000..86341dc
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_kerning_modes.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+An enumeration used to specify which kerning values to return in
+FT_Get_Kerning.
+
+
+FT_KERNING_DEFAULT
+
+ Return scaled and grid-fitted kerning distances (value is 0).
+
+
+FT_KERNING_UNFITTED
+
+ Return scaled but un-grid-fitted kerning distances.
+
+
+FT_KERNING_UNSCALED
+
+ Return the kerning vector in original font units.
+"""
+FT_KERNING_MODES = { 'FT_KERNING_DEFAULT' : 0,
+ 'FT_KERNING_UNFITTED' : 1,
+ 'FT_KERNING_UNSCALED' : 2 }
+globals().update(FT_KERNING_MODES)
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_lcd_filters.py b/third_party/freetype-py/freetype/ft_enums/ft_lcd_filters.py
new file mode 100644
index 0000000..355b190
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_lcd_filters.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+
+"""
+A list of values to identify various types of LCD filters.
+
+
+FT_LCD_FILTER_NONE
+
+ Do not perform filtering. When used with subpixel rendering, this results in
+ sometimes severe color fringes.
+
+
+FT_LCD_FILTER_DEFAULT
+
+ The default filter reduces color fringes considerably, at the cost of a
+ slight blurriness in the output.
+
+
+FT_LCD_FILTER_LIGHT
+
+ The light filter is a variant that produces less blurriness at the cost of
+ slightly more color fringes than the default one. It might be better,
+ depending on taste, your monitor, or your personal vision.
+
+
+FT_LCD_FILTER_LEGACY
+
+ This filter corresponds to the original libXft color filter. It provides high
+ contrast output but can exhibit really bad color fringes if glyphs are not
+ extremely well hinted to the pixel grid. In other words, it only works well
+ if the TrueType bytecode interpreter is enabled and high-quality hinted fonts
+ are used.
+
+ This filter is only provided for comparison purposes, and might be disabled
+ or stay unsupported in the future.
+"""
+
+FT_LCD_FILTERS = {'FT_LCD_FILTER_NONE' : 0,
+ 'FT_LCD_FILTER_DEFAULT' : 1,
+ 'FT_LCD_FILTER_LIGHT' : 2,
+ 'FT_LCD_FILTER_LEGACY' : 16}
+globals().update(FT_LCD_FILTERS)
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_load_flags.py b/third_party/freetype-py/freetype/ft_enums/ft_load_flags.py
new file mode 100644
index 0000000..ad79b7b
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_load_flags.py
@@ -0,0 +1,154 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of bit-field constants used with FT_Load_Glyph to indicate what kind
+of operations to perform during glyph loading.
+
+
+FT_LOAD_DEFAULT
+
+ Corresponding to 0, this value is used as the default glyph load
+ operation. In this case, the following happens:
+
+ 1. FreeType looks for a bitmap for the glyph corresponding to the face's
+ current size. If one is found, the function returns. The bitmap data can
+ be accessed from the glyph slot (see note below).
+
+ 2. If no embedded bitmap is searched or found, FreeType looks for a scalable
+ outline. If one is found, it is loaded from the font file, scaled to
+ device pixels, then 'hinted' to the pixel grid in order to optimize
+ it. The outline data can be accessed from the glyph slot (see note below).
+
+ Note that by default, the glyph loader doesn't render outlines into
+ bitmaps. The following flags are used to modify this default behaviour to
+ more specific and useful cases.
+
+
+FT_LOAD_NO_SCALE
+
+ Don't scale the outline glyph loaded, but keep it in font units.
+
+ This flag implies FT_LOAD_NO_HINTING and FT_LOAD_NO_BITMAP, and unsets
+ FT_LOAD_RENDER.
+
+
+FT_LOAD_NO_HINTING
+
+ Disable hinting. This generally generates 'blurrier' bitmap glyph when the
+ glyph is rendered in any of the anti-aliased modes. See also the note below.
+
+ This flag is implied by FT_LOAD_NO_SCALE.
+
+
+FT_LOAD_RENDER
+
+ Call FT_Render_Glyph after the glyph is loaded. By default, the glyph is
+ rendered in FT_RENDER_MODE_NORMAL mode. This can be overridden by
+ FT_LOAD_TARGET_XXX or FT_LOAD_MONOCHROME.
+
+ This flag is unset by FT_LOAD_NO_SCALE.
+
+
+FT_LOAD_NO_BITMAP
+
+ Ignore bitmap strikes when loading. Bitmap-only fonts ignore this flag.
+
+ FT_LOAD_NO_SCALE always sets this flag.
+
+
+FT_LOAD_VERTICAL_LAYOUT
+
+ Load the glyph for vertical text layout. Don't use it as it is problematic
+ currently.
+
+
+FT_LOAD_FORCE_AUTOHINT
+
+ Indicates that the auto-hinter is preferred over the font's native
+ hinter. See also the note below.
+
+
+FT_LOAD_CROP_BITMAP
+
+ Indicates that the font driver should crop the loaded bitmap glyph (i.e.,
+ remove all space around its black bits). Not all drivers implement this.
+
+
+FT_LOAD_PEDANTIC
+
+ Indicates that the font driver should perform pedantic verifications during
+ glyph loading. This is mostly used to detect broken glyphs in fonts. By
+ default, FreeType tries to handle broken fonts also.
+
+
+FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH
+
+ Indicates that the font driver should ignore the global advance width defined
+ in the font. By default, that value is used as the advance width for all
+ glyphs when the face has FT_FACE_FLAG_FIXED_WIDTH set.
+
+ This flag exists for historical reasons (to support buggy CJK fonts).
+
+
+FT_LOAD_NO_RECURSE
+
+ This flag is only used internally. It merely indicates that the font driver
+ should not load composite glyphs recursively. Instead, it should set the
+ 'num_subglyph' and 'subglyphs' values of the glyph slot accordingly, and set
+ 'glyph->format' to FT_GLYPH_FORMAT_COMPOSITE.
+
+ The description of sub-glyphs is not available to client applications for now.
+
+ This flag implies FT_LOAD_NO_SCALE and FT_LOAD_IGNORE_TRANSFORM.
+
+
+FT_LOAD_IGNORE_TRANSFORM
+
+ Indicates that the transform matrix set by FT_Set_Transform should be ignored.
+
+
+FT_LOAD_MONOCHROME
+
+ This flag is used with FT_LOAD_RENDER to indicate that you want to render an
+ outline glyph to a 1-bit monochrome bitmap glyph, with 8 pixels packed into
+ each byte of the bitmap data.
+
+ Note that this has no effect on the hinting algorithm used. You should rather
+ use FT_LOAD_TARGET_MONO so that the monochrome-optimized hinting algorithm is
+ used.
+
+
+FT_LOAD_LINEAR_DESIGN
+
+ Indicates that the 'linearHoriAdvance' and 'linearVertAdvance' fields of
+ FT_GlyphSlotRec should be kept in font units. See FT_GlyphSlotRec for
+ details.
+
+
+FT_LOAD_NO_AUTOHINT
+
+ Disable auto-hinter. See also the note below.
+"""
+
+FT_LOAD_FLAGS = { 'FT_LOAD_DEFAULT' : 0x0,
+ 'FT_LOAD_NO_SCALE' : 0x1,
+ 'FT_LOAD_NO_HINTING' : 0x2,
+ 'FT_LOAD_RENDER' : 0x4,
+ 'FT_LOAD_NO_BITMAP' : 0x8,
+ 'FT_LOAD_VERTICAL_LAYOUT' : 0x10,
+ 'FT_LOAD_FORCE_AUTOHINT' : 0x20,
+ 'FT_LOAD_CROP_BITMAP' : 0x40,
+ 'FT_LOAD_PEDANTIC' : 0x80,
+ 'FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH' : 0x200,
+ 'FT_LOAD_NO_RECURSE' : 0x400,
+ 'FT_LOAD_IGNORE_TRANSFORM' : 0x800,
+ 'FT_LOAD_MONOCHROME' : 0x1000,
+ 'FT_LOAD_LINEAR_DESIGN' : 0x2000,
+ 'FT_LOAD_NO_AUTOHINT' : 0x8000 }
+globals().update(FT_LOAD_FLAGS)
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_load_targets.py b/third_party/freetype-py/freetype/ft_enums/ft_load_targets.py
new file mode 100644
index 0000000..17e4949
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_load_targets.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of values that are used to select a specific hinting algorithm to use
+by the hinter. You should OR one of these values to your 'load_flags' when
+calling FT_Load_Glyph.
+
+Note that font's native hinters may ignore the hinting algorithm you have
+specified (e.g., the TrueType bytecode interpreter). You can set
+FT_LOAD_FORCE_AUTOHINT to ensure that the auto-hinter is used.
+
+Also note that FT_LOAD_TARGET_LIGHT is an exception, in that it always
+implies FT_LOAD_FORCE_AUTOHINT.
+
+
+FT_LOAD_TARGET_NORMAL
+
+ This corresponds to the default hinting algorithm, optimized for standard
+ gray-level rendering. For monochrome output, use FT_LOAD_TARGET_MONO instead.
+
+
+FT_LOAD_TARGET_LIGHT
+
+ A lighter hinting algorithm for non-monochrome modes. Many generated glyphs
+ are more fuzzy but better resemble its original shape. A bit like rendering
+ on Mac OS X.
+
+ As a special exception, this target implies FT_LOAD_FORCE_AUTOHINT.
+
+
+FT_LOAD_TARGET_MONO
+
+ Strong hinting algorithm that should only be used for monochrome output. The
+ result is probably unpleasant if the glyph is rendered in non-monochrome
+ modes.
+
+
+FT_LOAD_TARGET_LCD
+
+ A variant of FT_LOAD_TARGET_NORMAL optimized for horizontally decimated LCD
+ displays.
+
+
+FT_LOAD_TARGET_LCD_V
+
+ A variant of FT_LOAD_TARGET_NORMAL optimized for vertically decimated LCD
+ displays.
+"""
+
+from freetype.ft_enums.ft_render_modes import *
+
+
+def _FT_LOAD_TARGET_(x):
+ return (x & 15) << 16
+FT_LOAD_TARGETS = {
+ 'FT_LOAD_TARGET_NORMAL' : _FT_LOAD_TARGET_(FT_RENDER_MODE_NORMAL),
+ 'FT_LOAD_TARGET_LIGHT' : _FT_LOAD_TARGET_(FT_RENDER_MODE_LIGHT),
+ 'FT_LOAD_TARGET_MONO' : _FT_LOAD_TARGET_(FT_RENDER_MODE_MONO),
+ 'FT_LOAD_TARGET_LCD' : _FT_LOAD_TARGET_(FT_RENDER_MODE_LCD),
+ 'FT_LOAD_TARGET_LCD_V' : _FT_LOAD_TARGET_(FT_RENDER_MODE_LCD_V) }
+globals().update(FT_LOAD_TARGETS)
+#def FT_LOAD_TARGET_MODE(x):
+# return (x >> 16) & 15
+
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_open_modes.py b/third_party/freetype-py/freetype/ft_enums/ft_open_modes.py
new file mode 100644
index 0000000..b1149a5
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_open_modes.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of bit-field constants used within the 'flags' field of the
+FT_Open_Args structure.
+
+
+FT_OPEN_MEMORY
+
+ This is a memory-based stream.
+
+
+FT_OPEN_STREAM
+
+ Copy the stream from the 'stream' field.
+
+
+FT_OPEN_PATHNAME
+
+ Create a new input stream from a C path name.
+
+
+FT_OPEN_DRIVER
+
+ Use the 'driver' field.
+
+
+FT_OPEN_PARAMS
+
+ Use the 'num_params' and 'params' fields.
+"""
+FT_OPEN_MODES = {'FT_OPEN_MEMORY': 0x1,
+ 'FT_OPEN_STREAM': 0x2,
+ 'FT_OPEN_PATHNAME': 0x4,
+ 'FT_OPEN_DRIVER': 0x8,
+ 'FT_OPEN_PARAMS': 0x10 }
+globals().update(FT_OPEN_MODES)
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_outline_flags.py b/third_party/freetype-py/freetype/ft_enums/ft_outline_flags.py
new file mode 100644
index 0000000..644c225
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_outline_flags.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of bit-field constants use for the flags in an outline's 'flags'
+field.
+
+
+FT_OUTLINE_NONE
+
+ Value 0 is reserved.
+
+
+FT_OUTLINE_OWNER
+
+ If set, this flag indicates that the outline's field arrays (i.e., 'points',
+ 'flags', and 'contours') are 'owned' by the outline object, and should thus
+ be freed when it is destroyed.
+
+
+FT_OUTLINE_EVEN_ODD_FILL
+
+ By default, outlines are filled using the non-zero winding rule. If set to 1,
+ the outline will be filled using the even-odd fill rule (only works with the
+ smooth rasterizer).
+
+
+FT_OUTLINE_REVERSE_FILL
+
+ By default, outside contours of an outline are oriented in clock-wise
+ direction, as defined in the TrueType specification. This flag is set if the
+ outline uses the opposite direction (typically for Type 1 fonts). This flag
+ is ignored by the scan converter.
+
+
+FT_OUTLINE_IGNORE_DROPOUTS
+
+ By default, the scan converter will try to detect drop-outs in an outline and
+ correct the glyph bitmap to ensure consistent shape continuity. If set, this
+ flag hints the scan-line converter to ignore such cases. See below for more
+ information.
+
+
+FT_OUTLINE_SMART_DROPOUTS
+
+ Select smart dropout control. If unset, use simple dropout control. Ignored
+ if FT_OUTLINE_IGNORE_DROPOUTS is set. See below for more information.
+
+
+FT_OUTLINE_INCLUDE_STUBS
+
+ If set, turn pixels on for 'stubs', otherwise exclude them. Ignored if
+ FT_OUTLINE_IGNORE_DROPOUTS is set. See below for more information.
+
+
+FT_OUTLINE_HIGH_PRECISION
+
+ This flag indicates that the scan-line converter should try to convert this
+ outline to bitmaps with the highest possible quality. It is typically set for
+ small character sizes. Note that this is only a hint that might be completely
+ ignored by a given scan-converter.
+
+
+FT_OUTLINE_SINGLE_PASS
+
+ This flag is set to force a given scan-converter to only use a single pass
+ over the outline to render a bitmap glyph image. Normally, it is set for very
+ large character sizes. It is only a hint that might be completely ignored by
+ a given scan-converter.
+"""
+FT_OUTLINE_FLAGS = { 'FT_OUTLINE_NONE' : 0x0,
+ 'FT_OUTLINE_OWNER' : 0x1,
+ 'FT_OUTLINE_EVEN_ODD_FILL' : 0x2,
+ 'FT_OUTLINE_REVERSE_FILL' : 0x4,
+ 'FT_OUTLINE_IGNORE_DROPOUTS' : 0x8,
+ 'FT_OUTLINE_SMART_DROPOUTS' : 0x10,
+ 'FT_OUTLINE_INCLUDE_STUBS' : 0x20,
+ 'FT_OUTLINE_HIGH_PRECISION' : 0x100,
+ 'FT_OUTLINE_SINGLE_PASS' : 0x200 }
+globals().update(FT_OUTLINE_FLAGS)
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_pixel_modes.py b/third_party/freetype-py/freetype/ft_enums/ft_pixel_modes.py
new file mode 100644
index 0000000..2e11ed9
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_pixel_modes.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+An enumeration type that lists the render modes supported by FreeType 2. Each
+mode corresponds to a specific type of scanline conversion performed on the
+outline.
+
+
+FT_PIXEL_MODE_NONE
+
+ Value 0 is reserved.
+
+
+FT_PIXEL_MODE_MONO
+
+ A monochrome bitmap, using 1 bit per pixel. Note that pixels are stored in
+ most-significant order (MSB), which means that the left-most pixel in a byte
+ has value 128.
+
+
+FT_PIXEL_MODE_GRAY
+
+ An 8-bit bitmap, generally used to represent anti-aliased glyph images. Each
+ pixel is stored in one byte. Note that the number of 'gray' levels is stored
+ in the 'num_grays' field of the FT_Bitmap structure (it generally is 256).
+
+
+FT_PIXEL_MODE_GRAY2
+
+ A 2-bit per pixel bitmap, used to represent embedded anti-aliased bitmaps in
+ font files according to the OpenType specification. We haven't found a single
+ font using this format, however.
+
+
+FT_PIXEL_MODE_GRAY4
+
+ A 4-bit per pixel bitmap, representing embedded anti-aliased bitmaps in font
+ files according to the OpenType specification. We haven't found a single font
+ using this format, however.
+
+
+FT_PIXEL_MODE_LCD
+
+ An 8-bit bitmap, representing RGB or BGR decimated glyph images used for
+ display on LCD displays; the bitmap is three times wider than the original
+ glyph image. See also FT_RENDER_MODE_LCD.
+
+
+FT_PIXEL_MODE_LCD_V
+
+ An 8-bit bitmap, representing RGB or BGR decimated glyph images used for
+ display on rotated LCD displays; the bitmap is three times taller than the
+ original glyph image. See also FT_RENDER_MODE_LCD_V.
+
+"""
+
+FT_PIXEL_MODES = {'FT_PIXEL_MODE_NONE' : 0,
+ 'FT_PIXEL_MODE_MONO' : 1,
+ 'FT_PIXEL_MODE_GRAY' : 2,
+ 'FT_PIXEL_MODE_GRAY2': 3,
+ 'FT_PIXEL_MODE_GRAY4': 4,
+ 'FT_PIXEL_MODE_LCD' : 5,
+ 'FT_PIXEL_MODE_LCD_V': 6,
+ 'FT_PIXEL_MODE_MAX' : 7}
+globals().update(FT_PIXEL_MODES)
+ft_pixel_mode_none = FT_PIXEL_MODE_NONE
+ft_pixel_mode_mono = FT_PIXEL_MODE_MONO
+ft_pixel_mode_grays = FT_PIXEL_MODE_GRAY
+ft_pixel_mode_pal2 = FT_PIXEL_MODE_GRAY2
+ft_pixel_mode_pal4 = FT_PIXEL_MODE_GRAY4
+
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_render_modes.py b/third_party/freetype-py/freetype/ft_enums/ft_render_modes.py
new file mode 100644
index 0000000..dcda06f
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_render_modes.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+An enumeration type that lists the render modes supported by FreeType 2. Each
+mode corresponds to a specific type of scanline conversion performed on the
+outline.
+
+For bitmap fonts and embedded bitmaps the 'bitmap->pixel_mode' field in the
+FT_GlyphSlotRec structure gives the format of the returned bitmap.
+
+All modes except FT_RENDER_MODE_MONO use 256 levels of opacity.
+
+
+FT_RENDER_MODE_NORMAL
+
+ This is the default render mode; it corresponds to 8-bit anti-aliased
+ bitmaps.
+
+
+FT_RENDER_MODE_LIGHT
+
+ This is equivalent to FT_RENDER_MODE_NORMAL. It is only defined as a separate
+ value because render modes are also used indirectly to define hinting
+ algorithm selectors. See FT_LOAD_TARGET_XXX for details.
+
+
+FT_RENDER_MODE_MONO
+
+ This mode corresponds to 1-bit bitmaps (with 2 levels of opacity).
+
+
+FT_RENDER_MODE_LCD
+
+ This mode corresponds to horizontal RGB and BGR sub-pixel displays like LCD
+ screens. It produces 8-bit bitmaps that are 3 times the width of the original
+ glyph outline in pixels, and which use the FT_PIXEL_MODE_LCD mode.
+
+
+FT_RENDER_MODE_LCD_V
+
+ This mode corresponds to vertical RGB and BGR sub-pixel displays (like PDA
+ screens, rotated LCD displays, etc.). It produces 8-bit bitmaps that are 3
+ times the height of the original glyph outline in pixels and use the
+ FT_PIXEL_MODE_LCD_V mode.
+"""
+FT_RENDER_MODES = { 'FT_RENDER_MODE_NORMAL' : 0,
+ 'FT_RENDER_MODE_LIGHT' : 1,
+ 'FT_RENDER_MODE_MONO' : 2,
+ 'FT_RENDER_MODE_LCD' : 3,
+ 'FT_RENDER_MODE_LCD_V' : 4 }
+globals().update(FT_RENDER_MODES)
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_stroker_borders.py b/third_party/freetype-py/freetype/ft_enums/ft_stroker_borders.py
new file mode 100644
index 0000000..0c62cd4
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_stroker_borders.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+These values are used to select a given stroke border in
+FT_Stroker_GetBorderCounts and FT_Stroker_ExportBorder.
+
+
+FT_STROKER_BORDER_LEFT
+
+ Select the left border, relative to the drawing direction.
+
+
+FT_STROKER_BORDER_RIGHT
+
+ Select the right border, relative to the drawing direction.
+
+
+Note
+
+ Applications are generally interested in the 'inside' and 'outside'
+ borders. However, there is no direct mapping between these and the 'left' and
+ 'right' ones, since this really depends on the glyph's drawing orientation,
+ which varies between font formats.
+
+ You can however use FT_Outline_GetInsideBorder and
+ FT_Outline_GetOutsideBorder to get these.
+"""
+FT_STROKER_BORDERS = { 'FT_STROKER_BORDER_LEFT' : 0,
+ 'FT_STROKER_BORDER_RIGHT' : 1}
+globals().update(FT_STROKER_BORDERS)
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_stroker_linecaps.py b/third_party/freetype-py/freetype/ft_enums/ft_stroker_linecaps.py
new file mode 100644
index 0000000..19ebf1d
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_stroker_linecaps.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+These values determine how the end of opened sub-paths are rendered in a
+stroke.
+
+
+FT_STROKER_LINECAP_BUTT
+
+ The end of lines is rendered as a full stop on the last point itself.
+
+
+FT_STROKER_LINECAP_ROUND
+
+ The end of lines is rendered as a half-circle around the last point.
+
+
+FT_STROKER_LINECAP_SQUARE
+
+ The end of lines is rendered as a square around the last point.
+"""
+
+FT_STROKER_LINECAPS = { 'FT_STROKER_LINECAP_BUTT' : 0,
+ 'FT_STROKER_LINECAP_ROUND' : 1,
+ 'FT_STROKER_LINECAP_SQUARE' : 2}
+globals().update(FT_STROKER_LINECAPS)
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_stroker_linejoins.py b/third_party/freetype-py/freetype/ft_enums/ft_stroker_linejoins.py
new file mode 100644
index 0000000..f88191b
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_stroker_linejoins.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+These values determine how two joining lines are rendered in a stroker.
+
+
+FT_STROKER_LINEJOIN_ROUND
+
+ Used to render rounded line joins. Circular arcs are used to join two lines
+ smoothly.
+
+
+FT_STROKER_LINEJOIN_BEVEL
+
+ Used to render beveled line joins; i.e., the two joining lines are extended
+ until they intersect.
+
+
+FT_STROKER_LINEJOIN_MITER
+
+ Same as beveled rendering, except that an additional line break is added if
+ the angle between the two joining lines is too closed (this is useful to
+ avoid unpleasant spikes in beveled rendering).
+"""
+FT_STROKER_LINEJOINS = { 'FT_STROKER_LINEJOIN_ROUND' : 0,
+ 'FT_STROKER_LINEJOIN_BEVEL' : 1,
+ 'FT_STROKER_LINEJOIN_MITER' : 2}
+globals().update(FT_STROKER_LINEJOINS)
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/ft_style_flags.py b/third_party/freetype-py/freetype/ft_enums/ft_style_flags.py
new file mode 100644
index 0000000..e0032c9
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/ft_style_flags.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of bit-flags used to indicate the style of a given face. These are
+used in the 'style_flags' field of FT_FaceRec.
+
+
+FT_STYLE_FLAG_ITALIC
+
+ Indicates that a given face style is italic or oblique.
+
+
+FT_STYLE_FLAG_BOLD
+
+ Indicates that a given face is bold.
+"""
+FT_STYLE_FLAGS = {'FT_STYLE_FLAG_ITALIC' : 1,
+ 'FT_STYLE_FLAG_BOLD' : 2 }
+globals().update(FT_STYLE_FLAGS)
+
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/tt_adobe_ids.py b/third_party/freetype-py/freetype/ft_enums/tt_adobe_ids.py
new file mode 100644
index 0000000..40e243c
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/tt_adobe_ids.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of valid values for the 'encoding_id' for TT_PLATFORM_ADOBE
+charmaps. This is a FreeType-specific extension!
+
+TT_ADOBE_ID_STANDARD
+
+ Adobe standard encoding.
+
+
+TT_ADOBE_ID_EXPERT
+
+ Adobe expert encoding.
+
+
+TT_ADOBE_ID_CUSTOM
+
+ Adobe custom encoding.
+
+
+TT_ADOBE_ID_LATIN_1
+
+ Adobe Latin 1 encoding.
+"""
+
+TT_ADOBE_IDS = {
+ 'TT_ADOBE_ID_STANDARD' : 0,
+ 'TT_ADOBE_ID_EXPERT' : 1,
+ 'TT_ADOBE_ID_CUSTOM' : 2,
+ 'TT_ADOBE_ID_LATIN_1' : 3 }
+globals().update(TT_ADOBE_IDS)
diff --git a/third_party/freetype-py/freetype/ft_enums/tt_apple_ids.py b/third_party/freetype-py/freetype/ft_enums/tt_apple_ids.py
new file mode 100644
index 0000000..3d39fbd
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/tt_apple_ids.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of valid values for the 'encoding_id' for TT_PLATFORM_APPLE_UNICODE
+charmaps and name entries.
+
+
+TT_APPLE_ID_DEFAULT
+
+ Unicode version 1.0.
+
+
+TT_APPLE_ID_UNICODE_1_1
+
+ Unicode 1.1; specifies Hangul characters starting at U+34xx.
+
+
+TT_APPLE_ID_ISO_10646
+
+ Deprecated (identical to preceding).
+
+
+TT_APPLE_ID_UNICODE_2_0
+
+ Unicode 2.0 and beyond (UTF-16 BMP only).
+
+
+TT_APPLE_ID_UNICODE_32
+
+ Unicode 3.1 and beyond, using UTF-32.
+
+
+TT_APPLE_ID_VARIANT_SELECTOR
+
+ From Adobe, not Apple. Not a normal cmap. Specifies variations on a real
+ cmap.
+"""
+TT_APPLE_IDS = {
+ 'TT_APPLE_ID_DEFAULT' : 0,
+ 'TT_APPLE_ID_UNICODE_1_1' : 1,
+ 'TT_APPLE_ID_ISO_10646' : 2,
+ 'TT_APPLE_ID_UNICODE_2_0' : 3,
+ 'TT_APPLE_ID_UNICODE_32' : 4,
+ 'TT_APPLE_ID_VARIANT_SELECTOR' : 5 }
+globals().update(TT_APPLE_IDS)
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/tt_mac_ids.py b/third_party/freetype-py/freetype/ft_enums/tt_mac_ids.py
new file mode 100644
index 0000000..e455772
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/tt_mac_ids.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of valid values for the 'encoding_id' for TT_PLATFORM_MACINTOSH
+charmaps and name entries.
+
+TT_MAC_ID_ROMAN
+
+TT_MAC_ID_TELUGU
+
+TT_MAC_ID_GURMUKHI
+
+TT_MAC_ID_TIBETAN
+
+TT_MAC_ID_SIMPLIFIED_CHINESE
+
+TT_MAC_ID_SINDHI
+
+TT_MAC_ID_SINHALESE
+
+TT_MAC_ID_RUSSIAN
+
+TT_MAC_ID_KANNADA
+
+TT_MAC_ID_VIETNAMESE
+
+TT_MAC_ID_MONGOLIAN
+
+TT_MAC_ID_DEVANAGARI
+
+TT_MAC_ID_HEBREW
+
+TT_MAC_ID_TAMIL
+
+TT_MAC_ID_THAI
+
+TT_MAC_ID_BURMESE
+
+TT_MAC_ID_MALDIVIAN
+
+TT_MAC_ID_TRADITIONAL_CHINESE
+
+TT_MAC_ID_JAPANESE
+
+TT_MAC_ID_GREEK
+
+TT_MAC_ID_LAOTIAN
+
+TT_MAC_ID_KHMER
+
+TT_MAC_ID_UNINTERP
+
+TT_MAC_ID_ORIYA
+
+TT_MAC_ID_RSYMBOL
+
+TT_MAC_ID_MALAYALAM
+
+TT_MAC_ID_GEEZ
+
+TT_MAC_ID_KOREAN
+
+TT_MAC_ID_GUJARATI
+
+TT_MAC_ID_BENGALI
+
+TT_MAC_ID_ARABIC
+
+TT_MAC_ID_GEORGIAN
+
+TT_MAC_ID_ARMENIAN
+
+TT_MAC_ID_SLAVIC
+"""
+
+TT_MAC_IDS = {
+ 'TT_MAC_ID_ROMAN' : 0,
+ 'TT_MAC_ID_JAPANESE' : 1,
+ 'TT_MAC_ID_TRADITIONAL_CHINESE' : 2,
+ 'TT_MAC_ID_KOREAN' : 3,
+ 'TT_MAC_ID_ARABIC' : 4,
+ 'TT_MAC_ID_HEBREW' : 5,
+ 'TT_MAC_ID_GREEK' : 6,
+ 'TT_MAC_ID_RUSSIAN' : 7,
+ 'TT_MAC_ID_RSYMBOL' : 8,
+ 'TT_MAC_ID_DEVANAGARI' : 9,
+ 'TT_MAC_ID_GURMUKHI' : 10,
+ 'TT_MAC_ID_GUJARATI' : 11,
+ 'TT_MAC_ID_ORIYA' : 12,
+ 'TT_MAC_ID_BENGALI' : 13,
+ 'TT_MAC_ID_TAMIL' : 14,
+ 'TT_MAC_ID_TELUGU' : 15,
+ 'TT_MAC_ID_KANNADA' : 16,
+ 'TT_MAC_ID_MALAYALAM' : 17,
+ 'TT_MAC_ID_SINHALESE' : 18,
+ 'TT_MAC_ID_BURMESE' : 19,
+ 'TT_MAC_ID_KHMER' : 20,
+ 'TT_MAC_ID_THAI' : 21,
+ 'TT_MAC_ID_LAOTIAN' : 22,
+ 'TT_MAC_ID_GEORGIAN' : 23,
+ 'TT_MAC_ID_ARMENIAN' : 24,
+ 'TT_MAC_ID_MALDIVIAN' : 25,
+ 'TT_MAC_ID_SIMPLIFIED_CHINESE' : 25,
+ 'TT_MAC_ID_TIBETAN' : 26,
+ 'TT_MAC_ID_MONGOLIAN' : 27,
+ 'TT_MAC_ID_GEEZ' : 28,
+ 'TT_MAC_ID_SLAVIC' : 29,
+ 'TT_MAC_ID_VIETNAMESE' : 30,
+ 'TT_MAC_ID_SINDHI' : 31,
+ 'TT_MAC_ID_UNINTERP' : 32}
+globals().update(TT_MAC_IDS)
diff --git a/third_party/freetype-py/freetype/ft_enums/tt_mac_langids.py b/third_party/freetype-py/freetype/ft_enums/tt_mac_langids.py
new file mode 100644
index 0000000..2521aed
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/tt_mac_langids.py
@@ -0,0 +1,376 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+Possible values of the language identifier field in the name records of the
+TTF 'name' table if the 'platform' identifier code is TT_PLATFORM_MACINTOSH.
+
+TT_MAC_LANGID_LATIN
+
+TT_MAC_LANGID_MALAY_ARABIC_SCRIPT
+
+TT_MAC_LANGID_HINDI
+
+TT_MAC_LANGID_CATALAN
+
+TT_MAC_LANGID_MARATHI
+
+TT_MAC_LANGID_ICELANDIC
+
+TT_MAC_LANGID_ARABIC
+
+TT_MAC_LANGID_SWAHILI
+
+TT_MAC_LANGID_KHMER
+
+TT_MAC_LANGID_UKRAINIAN
+
+TT_MAC_LANGID_FINNISH
+
+TT_MAC_LANGID_POLISH
+
+TT_MAC_LANGID_NEPALI
+
+TT_MAC_LANGID_UZBEK
+
+TT_MAC_LANGID_TELUGU
+
+TT_MAC_LANGID_MALTESE
+
+TT_MAC_LANGID_AFRIKAANS
+
+TT_MAC_LANGID_CHEWA
+
+TT_MAC_LANGID_BASQUE
+
+TT_MAC_LANGID_CZECH
+
+TT_MAC_LANGID_ROMANIAN
+
+TT_MAC_LANGID_QUECHUA
+
+TT_MAC_LANGID_TAGALOG
+
+TT_MAC_LANGID_HUNGARIAN
+
+TT_MAC_LANGID_AZERBAIJANI_CYRILLIC_SCRIPT
+
+TT_MAC_LANGID_TONGAN
+
+TT_MAC_LANGID_SUNDANESE
+
+TT_MAC_LANGID_JAPANESE
+
+TT_MAC_LANGID_MONGOLIAN
+
+TT_MAC_LANGID_ALBANIAN
+
+TT_MAC_LANGID_NORWEGIAN
+
+TT_MAC_LANGID_SLOVAK
+
+TT_MAC_LANGID_MALAGASY
+
+TT_MAC_LANGID_DZONGKHA
+
+TT_MAC_LANGID_DUTCH
+
+TT_MAC_LANGID_MALAY_ROMAN_SCRIPT
+
+TT_MAC_LANGID_SERBIAN
+
+TT_MAC_LANGID_GERMAN
+
+TT_MAC_LANGID_SOMALI
+
+TT_MAC_LANGID_KOREAN
+
+TT_MAC_LANGID_MONGOLIAN_MONGOLIAN_SCRIPT
+
+TT_MAC_LANGID_CROATIAN
+
+TT_MAC_LANGID_TURKISH
+
+TT_MAC_LANGID_MOLDAVIAN
+
+TT_MAC_LANGID_LAO
+
+TT_MAC_LANGID_ORIYA
+
+TT_MAC_LANGID_BRETON
+
+TT_MAC_LANGID_PASHTO
+
+TT_MAC_LANGID_GUARANI
+
+TT_MAC_LANGID_HEBREW
+
+TT_MAC_LANGID_SLOVENIAN
+
+TT_MAC_LANGID_ESTONIAN
+
+TT_MAC_LANGID_RUNDI
+
+TT_MAC_LANGID_URDU
+
+TT_MAC_LANGID_CHINESE_TRADITIONAL
+
+TT_MAC_LANGID_TATAR
+
+TT_MAC_LANGID_CHINESE_SIMPLIFIED
+
+TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT
+
+TT_MAC_LANGID_SANSKRIT
+
+TT_MAC_LANGID_KURDISH
+
+TT_MAC_LANGID_FAEROESE
+
+TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT
+
+TT_MAC_LANGID_TIGRINYA
+
+TT_MAC_LANGID_THAI
+
+TT_MAC_LANGID_DANISH
+
+TT_MAC_LANGID_KAZAKH
+
+TT_MAC_LANGID_YIDDISH
+
+TT_MAC_LANGID_ESPERANTO
+
+TT_MAC_LANGID_LITHUANIAN
+
+TT_MAC_LANGID_FARSI
+
+TT_MAC_LANGID_LETTISH
+
+TT_MAC_LANGID_VIETNAMESE
+
+TT_MAC_LANGID_PORTUGUESE
+
+TT_MAC_LANGID_IRISH
+
+TT_MAC_LANGID_WELSH
+
+TT_MAC_LANGID_PUNJABI
+
+TT_MAC_LANGID_GREEK
+
+TT_MAC_LANGID_INUKTITUT
+
+TT_MAC_LANGID_FRENCH
+
+TT_MAC_LANGID_GREEK_POLYTONIC
+
+TT_MAC_LANGID_AZERBAIJANI
+
+TT_MAC_LANGID_JAVANESE
+
+TT_MAC_LANGID_SWEDISH
+
+TT_MAC_LANGID_UIGHUR
+
+TT_MAC_LANGID_BENGALI
+
+TT_MAC_LANGID_RUANDA
+
+TT_MAC_LANGID_SINDHI
+
+TT_MAC_LANGID_TIBETAN
+
+TT_MAC_LANGID_ENGLISH
+
+TT_MAC_LANGID_SAAMISK
+
+TT_MAC_LANGID_INDONESIAN
+
+TT_MAC_LANGID_MANX_GAELIC
+
+TT_MAC_LANGID_BYELORUSSIAN
+
+TT_MAC_LANGID_BULGARIAN
+
+TT_MAC_LANGID_GEORGIAN
+
+TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT
+
+TT_MAC_LANGID_ITALIAN
+
+TT_MAC_LANGID_SCOTTISH_GAELIC
+
+TT_MAC_LANGID_ARMENIAN
+
+TT_MAC_LANGID_GALLA
+
+TT_MAC_LANGID_MACEDONIAN
+
+TT_MAC_LANGID_IRISH_GAELIC
+
+TT_MAC_LANGID_KIRGHIZ
+
+TT_MAC_LANGID_TAMIL
+
+TT_MAC_LANGID_SPANISH
+
+TT_MAC_LANGID_BURMESE
+
+TT_MAC_LANGID_KANNADA
+
+TT_MAC_LANGID_GALICIAN
+
+TT_MAC_LANGID_FLEMISH
+
+TT_MAC_LANGID_TAJIKI
+
+TT_MAC_LANGID_ASSAMESE
+
+TT_MAC_LANGID_SINHALESE
+
+TT_MAC_LANGID_GREELANDIC
+
+TT_MAC_LANGID_AMHARIC
+
+TT_MAC_LANGID_KASHMIRI
+
+TT_MAC_LANGID_AYMARA
+
+TT_MAC_LANGID_GUJARATI
+
+TT_MAC_LANGID_RUSSIAN
+
+TT_MAC_LANGID_TURKMEN
+
+TT_MAC_LANGID_MALAYALAM
+"""
+TT_MAC_LANGIDS = {
+ 'TT_MAC_LANGID_ENGLISH' : 0,
+ 'TT_MAC_LANGID_FRENCH' : 1,
+ 'TT_MAC_LANGID_GERMAN' : 2,
+ 'TT_MAC_LANGID_ITALIAN' : 3,
+ 'TT_MAC_LANGID_DUTCH' : 4,
+ 'TT_MAC_LANGID_SWEDISH' : 5,
+ 'TT_MAC_LANGID_SPANISH' : 6,
+ 'TT_MAC_LANGID_DANISH' : 7,
+ 'TT_MAC_LANGID_PORTUGUESE' : 8,
+ 'TT_MAC_LANGID_NORWEGIAN' : 9,
+ 'TT_MAC_LANGID_HEBREW' : 10,
+ 'TT_MAC_LANGID_JAPANESE' : 11,
+ 'TT_MAC_LANGID_ARABIC' : 12,
+ 'TT_MAC_LANGID_FINNISH' : 13,
+ 'TT_MAC_LANGID_GREEK' : 14,
+ 'TT_MAC_LANGID_ICELANDIC' : 15,
+ 'TT_MAC_LANGID_MALTESE' : 16,
+ 'TT_MAC_LANGID_TURKISH' : 17,
+ 'TT_MAC_LANGID_CROATIAN' : 18,
+ 'TT_MAC_LANGID_CHINESE_TRADITIONAL' : 19,
+ 'TT_MAC_LANGID_URDU' : 20,
+ 'TT_MAC_LANGID_HINDI' : 21,
+ 'TT_MAC_LANGID_THAI' : 22,
+ 'TT_MAC_LANGID_KOREAN' : 23,
+ 'TT_MAC_LANGID_LITHUANIAN' : 24,
+ 'TT_MAC_LANGID_POLISH' : 25,
+ 'TT_MAC_LANGID_HUNGARIAN' : 26,
+ 'TT_MAC_LANGID_ESTONIAN' : 27,
+ 'TT_MAC_LANGID_LETTISH' : 28,
+ 'TT_MAC_LANGID_SAAMISK' : 29,
+ 'TT_MAC_LANGID_FAEROESE' : 30,
+ 'TT_MAC_LANGID_FARSI' : 31,
+ 'TT_MAC_LANGID_RUSSIAN' : 32,
+ 'TT_MAC_LANGID_CHINESE_SIMPLIFIED' : 33,
+ 'TT_MAC_LANGID_FLEMISH' : 34,
+ 'TT_MAC_LANGID_IRISH' : 35,
+ 'TT_MAC_LANGID_ALBANIAN' : 36,
+ 'TT_MAC_LANGID_ROMANIAN' : 37,
+ 'TT_MAC_LANGID_CZECH' : 38,
+ 'TT_MAC_LANGID_SLOVAK' : 39,
+ 'TT_MAC_LANGID_SLOVENIAN' : 40,
+ 'TT_MAC_LANGID_YIDDISH' : 41,
+ 'TT_MAC_LANGID_SERBIAN' : 42,
+ 'TT_MAC_LANGID_MACEDONIAN' : 43,
+ 'TT_MAC_LANGID_BULGARIAN' : 44,
+ 'TT_MAC_LANGID_UKRAINIAN' : 45,
+ 'TT_MAC_LANGID_BYELORUSSIAN' : 46,
+ 'TT_MAC_LANGID_UZBEK' : 47,
+ 'TT_MAC_LANGID_KAZAKH' : 48,
+ 'TT_MAC_LANGID_AZERBAIJANI' : 49,
+ 'TT_MAC_LANGID_AZERBAIJANI_CYRILLIC_SCRIPT': 49,
+ 'TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT' : 50,
+ 'TT_MAC_LANGID_ARMENIAN' : 51,
+ 'TT_MAC_LANGID_GEORGIAN' : 52,
+ 'TT_MAC_LANGID_MOLDAVIAN' : 53,
+ 'TT_MAC_LANGID_KIRGHIZ' : 54,
+ 'TT_MAC_LANGID_TAJIKI' : 55,
+ 'TT_MAC_LANGID_TURKMEN' : 56,
+ 'TT_MAC_LANGID_MONGOLIAN' : 57,
+ 'TT_MAC_LANGID_MONGOLIAN_MONGOLIAN_SCRIPT' : 57,
+ 'TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT' : 58,
+ 'TT_MAC_LANGID_PASHTO' : 59,
+ 'TT_MAC_LANGID_KURDISH' : 60,
+ 'TT_MAC_LANGID_KASHMIRI' : 61,
+ 'TT_MAC_LANGID_SINDHI' : 62,
+ 'TT_MAC_LANGID_TIBETAN' : 63,
+ 'TT_MAC_LANGID_NEPALI' : 64,
+ 'TT_MAC_LANGID_SANSKRIT' : 65,
+ 'TT_MAC_LANGID_MARATHI' : 66,
+ 'TT_MAC_LANGID_BENGALI' : 67,
+ 'TT_MAC_LANGID_ASSAMESE' : 68,
+ 'TT_MAC_LANGID_GUJARATI' : 69,
+ 'TT_MAC_LANGID_PUNJABI' : 70,
+ 'TT_MAC_LANGID_ORIYA' : 71,
+ 'TT_MAC_LANGID_MALAYALAM' : 72,
+ 'TT_MAC_LANGID_KANNADA' : 73,
+ 'TT_MAC_LANGID_TAMIL' : 74,
+ 'TT_MAC_LANGID_TELUGU' : 75,
+ 'TT_MAC_LANGID_SINHALESE' : 76,
+ 'TT_MAC_LANGID_BURMESE' : 77,
+ 'TT_MAC_LANGID_KHMER' : 78,
+ 'TT_MAC_LANGID_LAO' : 79,
+ 'TT_MAC_LANGID_VIETNAMESE' : 80,
+ 'TT_MAC_LANGID_INDONESIAN' : 81,
+ 'TT_MAC_LANGID_TAGALOG' : 82,
+ 'TT_MAC_LANGID_MALAY_ROMAN_SCRIPT' : 83,
+ 'TT_MAC_LANGID_MALAY_ARABIC_SCRIPT' : 84,
+ 'TT_MAC_LANGID_AMHARIC' : 85,
+ 'TT_MAC_LANGID_TIGRINYA' : 86,
+ 'TT_MAC_LANGID_GALLA' : 87,
+ 'TT_MAC_LANGID_SOMALI' : 88,
+ 'TT_MAC_LANGID_SWAHILI' : 89,
+ 'TT_MAC_LANGID_RUANDA' : 90,
+ 'TT_MAC_LANGID_RUNDI' : 91,
+ 'TT_MAC_LANGID_CHEWA' : 92,
+ 'TT_MAC_LANGID_MALAGASY' : 93,
+ 'TT_MAC_LANGID_ESPERANTO' : 94,
+ 'TT_MAC_LANGID_WELSH' : 128,
+ 'TT_MAC_LANGID_BASQUE' : 129,
+ 'TT_MAC_LANGID_CATALAN' : 130,
+ 'TT_MAC_LANGID_LATIN' : 131,
+ 'TT_MAC_LANGID_QUECHUA' : 132,
+ 'TT_MAC_LANGID_GUARANI' : 133,
+ 'TT_MAC_LANGID_AYMARA' : 134,
+ 'TT_MAC_LANGID_TATAR' : 135,
+ 'TT_MAC_LANGID_UIGHUR' : 136,
+ 'TT_MAC_LANGID_DZONGKHA' : 137,
+ 'TT_MAC_LANGID_JAVANESE' : 138,
+ 'TT_MAC_LANGID_SUNDANESE' : 139,
+ 'TT_MAC_LANGID_GALICIAN' : 140,
+ 'TT_MAC_LANGID_AFRIKAANS' : 141,
+ 'TT_MAC_LANGID_BRETON' : 142,
+ 'TT_MAC_LANGID_INUKTITUT' : 143,
+ 'TT_MAC_LANGID_SCOTTISH_GAELIC' : 144,
+ 'TT_MAC_LANGID_MANX_GAELIC' : 145,
+ 'TT_MAC_LANGID_IRISH_GAELIC' : 146,
+ 'TT_MAC_LANGID_TONGAN' : 147,
+ 'TT_MAC_LANGID_GREEK_POLYTONIC' : 148,
+ 'TT_MAC_LANGID_GREELANDIC' : 149,
+ 'TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT' : 150 }
+globals().update(TT_MAC_LANGIDS)
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/tt_ms_ids.py b/third_party/freetype-py/freetype/ft_enums/tt_ms_ids.py
new file mode 100644
index 0000000..43b0af8
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/tt_ms_ids.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of valid values for the 'encoding_id' for TT_PLATFORM_MICROSOFT
+charmaps and name entries.
+
+
+TT_MS_ID_SYMBOL_CS
+
+ Corresponds to Microsoft symbol encoding. See FT_ENCODING_MS_SYMBOL.
+
+
+TT_MS_ID_UNICODE_CS
+
+ Corresponds to a Microsoft WGL4 charmap, matching Unicode. See
+ FT_ENCODING_UNICODE.
+
+
+TT_MS_ID_SJIS
+
+ Corresponds to SJIS Japanese encoding. See FT_ENCODING_SJIS.
+
+
+TT_MS_ID_GB2312
+
+ Corresponds to Simplified Chinese as used in Mainland China. See
+ FT_ENCODING_GB2312.
+
+
+TT_MS_ID_BIG_5
+
+ Corresponds to Traditional Chinese as used in Taiwan and Hong Kong. See
+ FT_ENCODING_BIG5.
+
+
+TT_MS_ID_WANSUNG
+
+ Corresponds to Korean Wansung encoding. See FT_ENCODING_WANSUNG.
+
+TT_MS_ID_JOHAB
+
+ Corresponds to Johab encoding. See FT_ENCODING_JOHAB.
+
+
+TT_MS_ID_UCS_4
+
+ Corresponds to UCS-4 or UTF-32 charmaps. This has been added to the OpenType
+ specification version 1.4 (mid-2001.)
+"""
+
+TT_MS_IDS = {
+ 'TT_MS_ID_SYMBOL_CS' : 0,
+ 'TT_MS_ID_UNICODE_CS' : 1,
+ 'TT_MS_ID_SJIS' : 2,
+ 'TT_MS_ID_GB2312' : 3,
+ 'TT_MS_ID_BIG_5' : 4,
+ 'TT_MS_ID_WANSUNG' : 5,
+ 'TT_MS_ID_JOHAB' : 6,
+ 'TT_MS_ID_UCS_4' : 10 }
+globals().update(TT_MS_IDS)
+
+
diff --git a/third_party/freetype-py/freetype/ft_enums/tt_ms_langids.py b/third_party/freetype-py/freetype/ft_enums/tt_ms_langids.py
new file mode 100644
index 0000000..7258b58
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/tt_ms_langids.py
@@ -0,0 +1,751 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+Possible values of the language identifier field in the name records of the
+TTF 'name' table if the 'platform' identifier code is TT_PLATFORM_MICROSOFT.
+
+TT_MS_LANGID_SANSKRIT_INDIA
+
+TT_MS_LANGID_ENGLISH_UNITED_KINGDOM
+
+TT_MS_LANGID_ENGLISH_BELIZE
+
+TT_MS_LANGID_ARABIC_LEBANON
+
+TT_MS_LANGID_MOLDAVIAN_MOLDAVIA
+
+TT_MS_LANGID_TURKISH_TURKEY
+
+TT_MS_LANGID_WELSH_WALES
+
+TT_MS_LANGID_GERMAN_AUSTRIA
+
+TT_MS_LANGID_DUTCH_BELGIUM
+
+TT_MS_LANGID_YI_CHINA
+
+TT_MS_LANGID_QUECHUA_ECUADOR
+
+TT_MS_LANGID_SPANISH_EL_SALVADOR
+
+TT_MS_LANGID_SWAHILI_KENYA
+
+TT_MS_LANGID_QUECHUA_BOLIVIA
+
+TT_MS_LANGID_SLOVENE_SLOVENIA
+
+TT_MS_LANGID_ORIYA_INDIA
+
+TT_MS_LANGID_FARSI_IRAN
+
+TT_MS_LANGID_ENGLISH_CANADA
+
+TT_MS_LANGID_NEPALI_NEPAL
+
+TT_MS_LANGID_DHIVEHI_MALDIVES
+
+TT_MS_LANGID_GERMAN_LIECHTENSTEI
+
+TT_MS_LANGID_TAMIL_INDIA
+
+TT_MS_LANGID_ARABIC_UAE
+
+TT_MS_LANGID_JAPANESE_JAPAN
+
+TT_MS_LANGID_TAMAZIGHT_MOROCCO
+
+TT_MS_LANGID_FRENCH_FRANCE
+
+TT_MS_LANGID_CHINESE_MACAU
+
+TT_MS_LANGID_VIETNAMESE_VIET_NAM
+
+TT_MS_LANGID_HEBREW_ISRAEL
+
+TT_MS_LANGID_SAMI_NORTHERN_SWEDEN
+
+TT_MS_LANGID_PUNJABI_ARABIC_PAKISTAN
+
+TT_MS_LANGID_SWEDISH_SWEDEN
+
+TT_MS_LANGID_FRENCH_REUNION
+
+TT_MS_LANGID_ARABIC_BAHRAIN
+
+TT_MS_LANGID_ENGLISH_INDIA
+
+TT_MS_LANGID_NEPALI_INDIA
+
+TT_MS_LANGID_THAI_THAILAND
+
+TT_MS_LANGID_ENGLISH_GENERAL
+
+TT_MS_LANGID_SAMI_LULE_NORWAY
+
+TT_MS_LANGID_ARABIC_OMAN
+
+TT_MS_LANGID_SPANISH_HONDURAS
+
+TT_MS_LANGID_ENGLISH_JAMAICA
+
+TT_MS_LANGID_ESTONIAN_ESTONIA
+
+TT_MS_LANGID_FRISIAN_NETHERLANDS
+
+TT_MS_LANGID_LATIN
+
+TT_MS_LANGID_ENGLISH_INDONESIA
+
+TT_MS_LANGID_ENGLISH_IRELAND
+
+TT_MS_LANGID_TIBETAN_CHINA
+
+TT_MS_LANGID_PUNJABI_INDIA
+
+TT_MS_LANGID_FRENCH_MALI
+
+TT_MS_LANGID_GERMAN_LUXEMBOURG
+
+TT_MS_LANGID_SUTU_SOUTH_AFRICA
+
+TT_MS_LANGID_FRENCH_CAMEROON
+
+TT_MS_LANGID_FRENCH_CONGO
+
+TT_MS_LANGID_CLASSIC_LITHUANIAN_LITHUANIA
+
+TT_MS_LANGID_MALAYALAM_INDIA
+
+TT_MS_LANGID_SAMI_SOUTHERN_SWEDEN
+
+TT_MS_LANGID_CHEROKEE_UNITED_STATES
+
+TT_MS_LANGID_SPANISH_GUATEMALA
+
+TT_MS_LANGID_CZECH_CZECH_REPUBLIC
+
+TT_MS_LANGID_MANIPURI_INDIA
+
+TT_MS_LANGID_ENGLISH_AUSTRALIA
+
+TT_MS_LANGID_SPANISH_DOMINICAN_REPUBLIC
+
+TT_MS_LANGID_ARABIC_LIBYA
+
+TT_MS_LANGID_FRENCH_WEST_INDIES
+
+TT_MS_LANGID_ENGLISH_TRINIDAD
+
+TT_MS_LANGID_ARABIC_QATAR
+
+TT_MS_LANGID_SPANISH_COLOMBIA
+
+TT_MS_LANGID_GUARANI_PARAGUAY
+
+TT_MS_LANGID_EDO_NIGERIA
+
+TT_MS_LANGID_SEPEDI_SOUTH_AFRICA
+
+TT_MS_LANGID_ENGLISH_HONG_KONG
+
+TT_MS_LANGID_KOREAN_EXTENDED_WANSUNG_KOREA
+
+TT_MS_LANGID_TATAR_TATARSTAN
+
+TT_MS_LANGID_PASHTO_AFGHANISTAN
+
+TT_MS_LANGID_KASHMIRI_PAKISTAN
+
+TT_MS_LANGID_GALICIAN_SPAIN
+
+TT_MS_LANGID_TAJIK_TAJIKISTAN
+
+TT_MS_LANGID_SAMI_INARI_FINLAND
+
+TT_MS_LANGID_KASHMIRI_SASIA
+
+TT_MS_LANGID_SPANISH_ARGENTINA
+
+TT_MS_LANGID_SAMI_SOUTHERN_NORWAY
+
+TT_MS_LANGID_CROATIAN_CROATIA
+
+TT_MS_LANGID_GUJARATI_INDIA
+
+TT_MS_LANGID_TIBETAN_BHUTAN
+
+TT_MS_LANGID_TIGRIGNA_ETHIOPIA
+
+TT_MS_LANGID_FINNISH_FINLAND
+
+TT_MS_LANGID_ENGLISH_UNITED_STATES
+
+TT_MS_LANGID_ITALIAN_SWITZERLAND
+
+TT_MS_LANGID_ARABIC_EGYPT
+
+TT_MS_LANGID_SPANISH_LATIN_AMERICA
+
+TT_MS_LANGID_LITHUANIAN_LITHUANIA
+
+TT_MS_LANGID_ARABIC_ALGERIA
+
+TT_MS_LANGID_MALAY_MALAYSIA
+
+TT_MS_LANGID_ARABIC_GENERAL
+
+TT_MS_LANGID_CHINESE_PRC
+
+TT_MS_LANGID_BENGALI_BANGLADESH
+
+TT_MS_LANGID_SPANISH_PERU
+
+TT_MS_LANGID_SPANISH_SPAIN_INTERNATIONAL_SORT
+
+TT_MS_LANGID_DIVEHI_MALDIVES
+
+TT_MS_LANGID_LATVIAN_LATVIA
+
+TT_MS_LANGID_TURKMEN_TURKMENISTAN
+
+TT_MS_LANGID_XHOSA_SOUTH_AFRICA
+
+TT_MS_LANGID_KHMER_CAMBODIA
+
+TT_MS_LANGID_NORWEGIAN_NORWAY_NYNORSK
+
+TT_MS_LANGID_ARABIC_MOROCCO
+
+TT_MS_LANGID_FRENCH_SENEGAL
+
+TT_MS_LANGID_YORUBA_NIGERIA
+
+TT_MS_LANGID_CATALAN_SPAIN
+
+TT_MS_LANGID_AFRIKAANS_SOUTH_AFRICA
+
+TT_MS_LANGID_ZULU_SOUTH_AFRICA
+
+TT_MS_LANGID_SPANISH_URUGUAY
+
+TT_MS_LANGID_SPANISH_ECUADOR
+
+TT_MS_LANGID_BOSNIAN_BOSNIA_HERZEGOVINA
+
+TT_MS_LANGID_CHINESE_GENERAL
+
+TT_MS_LANGID_SPANISH_PARAGUAY
+
+TT_MS_LANGID_HINDI_INDIA
+
+TT_MS_LANGID_FRENCH_LUXEMBOURG
+
+TT_MS_LANGID_TSWANA_SOUTH_AFRICA
+
+TT_MS_LANGID_HUNGARIAN_HUNGARY
+
+TT_MS_LANGID_CROATIAN_BOSNIA_HERZEGOVINA
+
+TT_MS_LANGID_ENGLISH_SINGAPORE
+
+TT_MS_LANGID_MALTESE_MALTA
+
+TT_MS_LANGID_SAMI_NORTHERN_FINLAND
+
+TT_MS_LANGID_FRENCH_CANADA
+
+TT_MS_LANGID_SAMI_LULE_SWEDEN
+
+TT_MS_LANGID_KANURI_NIGERIA
+
+TT_MS_LANGID_IRISH_GAELIC_IRELAND
+
+TT_MS_LANGID_ARABIC_SAUDI_ARABIA
+
+TT_MS_LANGID_FRENCH_HAITI
+
+TT_MS_LANGID_SPANISH_PUERTO_RICO
+
+TT_MS_LANGID_BURMESE_MYANMAR
+
+TT_MS_LANGID_POLISH_POLAND
+
+TT_MS_LANGID_PORTUGUESE_PORTUGAL
+
+TT_MS_LANGID_ENGLISH_CARIBBEAN
+
+TT_MS_LANGID_KIRGHIZ_KIRGHIZ_REPUBLIC
+
+TT_MS_LANGID_ICELANDIC_ICELAND
+
+TT_MS_LANGID_BENGALI_INDIA
+
+TT_MS_LANGID_HAUSA_NIGERIA
+
+TT_MS_LANGID_BASQUE_SPAIN
+
+TT_MS_LANGID_UIGHUR_CHINA
+
+TT_MS_LANGID_ENGLISH_MALAYSIA
+
+TT_MS_LANGID_FRENCH_MONACO
+
+TT_MS_LANGID_SPANISH_BOLIVIA
+
+TT_MS_LANGID_SORBIAN_GERMANY
+
+TT_MS_LANGID_SINDHI_INDIA
+
+TT_MS_LANGID_CHINESE_SINGAPORE
+
+TT_MS_LANGID_FRENCH_COTE_D_IVOIRE
+
+TT_MS_LANGID_SPANISH_SPAIN_TRADITIONAL_SORT
+
+TT_MS_LANGID_SERBIAN_SERBIA_CYRILLIC
+
+TT_MS_LANGID_SAMI_SKOLT_FINLAND
+
+TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_CYRILLIC
+
+TT_MS_LANGID_MALAY_BRUNEI_DARUSSALAM
+
+TT_MS_LANGID_ARABIC_JORDAN
+
+TT_MS_LANGID_MONGOLIAN_MONGOLIA_MONGOLIAN
+
+TT_MS_LANGID_SERBIAN_SERBIA_LATIN
+
+TT_MS_LANGID_RUSSIAN_RUSSIA
+
+TT_MS_LANGID_ROMANIAN_ROMANIA
+
+TT_MS_LANGID_FRENCH_NORTH_AFRICA
+
+TT_MS_LANGID_MONGOLIAN_MONGOLIA
+
+TT_MS_LANGID_TSONGA_SOUTH_AFRICA
+
+TT_MS_LANGID_SOMALI_SOMALIA
+
+TT_MS_LANGID_SAAMI_LAPONIA
+
+TT_MS_LANGID_SPANISH_COSTA_RICA
+
+TT_MS_LANGID_ARABIC_SYRIA
+
+TT_MS_LANGID_SPANISH_PANAMA
+
+TT_MS_LANGID_PAPIAMENTU_NETHERLANDS_ANTILLES
+
+TT_MS_LANGID_ASSAMESE_INDIA
+
+TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM
+
+TT_MS_LANGID_DUTCH_NETHERLANDS
+
+TT_MS_LANGID_SINDHI_PAKISTAN
+
+TT_MS_LANGID_MACEDONIAN_MACEDONIA
+
+TT_MS_LANGID_KAZAK_KAZAKSTAN
+
+TT_MS_LANGID_AZERI_AZERBAIJAN_LATIN
+
+TT_MS_LANGID_BELARUSIAN_BELARUS
+
+TT_MS_LANGID_FRENCH_MOROCCO
+
+TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_LATIN
+
+TT_MS_LANGID_ALBANIAN_ALBANIA
+
+TT_MS_LANGID_SINHALESE_SRI_LANKA
+
+TT_MS_LANGID_SPANISH_MEXICO
+
+TT_MS_LANGID_ENGLISH_ZIMBABWE
+
+TT_MS_LANGID_OROMO_ETHIOPIA
+
+TT_MS_LANGID_INDONESIAN_INDONESIA
+
+TT_MS_LANGID_SAMI_NORTHERN_NORWAY
+
+TT_MS_LANGID_UZBEK_UZBEKISTAN_LATIN
+
+TT_MS_LANGID_SLOVAK_SLOVAKIA
+
+TT_MS_LANGID_KASHMIRI_INDIA
+
+TT_MS_LANGID_GERMAN_SWITZERLAND
+
+TT_MS_LANGID_URDU_INDIA
+
+TT_MS_LANGID_FAEROESE_FAEROE_ISLANDS
+
+TT_MS_LANGID_SYRIAC_SYRIA
+
+TT_MS_LANGID_SPANISH_CHILE
+
+TT_MS_LANGID_FILIPINO_PHILIPPINES
+
+TT_MS_LANGID_ARABIC_YEMEN
+
+TT_MS_LANGID_KONKANI_INDIA
+
+TT_MS_LANGID_AMHARIC_ETHIOPIA
+
+TT_MS_LANGID_ENGLISH_NEW_ZEALAND
+
+TT_MS_LANGID_RHAETO_ROMANIC_SWITZERLAND
+
+TT_MS_LANGID_ARABIC_TUNISIA
+
+TT_MS_LANGID_SOTHO_SOUTHERN_SOUTH_AFRICA
+
+TT_MS_LANGID_QUECHUA_PERU
+
+TT_MS_LANGID_DANISH_DENMARK
+
+TT_MS_LANGID_ENGLISH_PHILIPPINES
+
+TT_MS_LANGID_SPANISH_NICARAGUA
+
+TT_MS_LANGID_INUKTITUT_CANADA
+
+TT_MS_LANGID_UKRAINIAN_UKRAINE
+
+TT_MS_LANGID_NORWEGIAN_NORWAY_BOKMAL
+
+TT_MS_LANGID_UZBEK_UZBEKISTAN_CYRILLIC
+
+TT_MS_LANGID_FRENCH_BELGIUM
+
+TT_MS_LANGID_ENGLISH_SOUTH_AFRICA
+
+TT_MS_LANGID_HAWAIIAN_UNITED_STATES
+
+TT_MS_LANGID_ARABIC_IRAQ
+
+TT_MS_LANGID_KANNADA_INDIA
+
+TT_MS_LANGID_DZONGHKA_BHUTAN
+
+TT_MS_LANGID_CHINESE_TAIWAN
+
+TT_MS_LANGID_SPANISH_UNITED_STATES
+
+TT_MS_LANGID_ARMENIAN_ARMENIA
+
+TT_MS_LANGID_LAO_LAOS
+
+TT_MS_LANGID_TIGRIGNA_ERYTREA
+
+TT_MS_LANGID_MARATHI_INDIA
+
+TT_MS_LANGID_ARABIC_KUWAIT
+
+TT_MS_LANGID_TAMAZIGHT_MOROCCO_LATIN
+
+TT_MS_LANGID_PORTUGUESE_BRAZIL
+
+TT_MS_LANGID_TIGRIGNA_ERYTHREA
+
+TT_MS_LANGID_GREEK_GREECE
+
+TT_MS_LANGID_URDU_PAKISTAN
+
+TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN
+
+TT_MS_LANGID_YIDDISH_GERMANY
+
+TT_MS_LANGID_GERMAN_GERMANY
+
+TT_MS_LANGID_TELUGU_INDIA
+
+TT_MS_LANGID_AZERI_AZERBAIJAN_CYRILLIC
+
+TT_MS_LANGID_KOREAN_JOHAB_KOREA
+
+TT_MS_LANGID_ITALIAN_ITALY
+
+TT_MS_LANGID_MAORI_NEW_ZEALAND
+
+TT_MS_LANGID_SPANISH_VENEZUELA
+
+TT_MS_LANGID_IGBO_NIGERIA
+
+TT_MS_LANGID_IBIBIO_NIGERIA
+
+TT_MS_LANGID_CHINESE_HONG_KONG
+
+TT_MS_LANGID_FRENCH_SWITZERLAND
+
+TT_MS_LANGID_BULGARIAN_BULGARIA
+
+TT_MS_LANGID_FULFULDE_NIGERIA
+
+TT_MS_LANGID_RUSSIAN_MOLDAVIA
+
+TT_MS_LANGID_VENDA_SOUTH_AFRICA
+
+TT_MS_LANGID_GEORGIAN_GEORGIA
+
+TT_MS_LANGID_SWEDISH_FINLAND
+"""
+
+TT_MS_LANGIDS = {
+ 'TT_MS_LANGID_ARABIC_GENERAL' : 0x0001,
+ 'TT_MS_LANGID_ARABIC_SAUDI_ARABIA' : 0x0401,
+ 'TT_MS_LANGID_ARABIC_IRAQ' : 0x0801,
+ 'TT_MS_LANGID_ARABIC_EGYPT' : 0x0c01,
+ 'TT_MS_LANGID_ARABIC_LIBYA' : 0x1001,
+ 'TT_MS_LANGID_ARABIC_ALGERIA' : 0x1401,
+ 'TT_MS_LANGID_ARABIC_MOROCCO' : 0x1801,
+ 'TT_MS_LANGID_ARABIC_TUNISIA' : 0x1c01,
+ 'TT_MS_LANGID_ARABIC_OMAN' : 0x2001,
+ 'TT_MS_LANGID_ARABIC_YEMEN' : 0x2401,
+ 'TT_MS_LANGID_ARABIC_SYRIA' : 0x2801,
+ 'TT_MS_LANGID_ARABIC_JORDAN' : 0x2c01,
+ 'TT_MS_LANGID_ARABIC_LEBANON' : 0x3001,
+ 'TT_MS_LANGID_ARABIC_KUWAIT' : 0x3401,
+ 'TT_MS_LANGID_ARABIC_UAE' : 0x3801,
+ 'TT_MS_LANGID_ARABIC_BAHRAIN' : 0x3c01,
+ 'TT_MS_LANGID_ARABIC_QATAR' : 0x4001,
+ 'TT_MS_LANGID_BULGARIAN_BULGARIA' : 0x0402,
+ 'TT_MS_LANGID_CATALAN_SPAIN' : 0x0403,
+ 'TT_MS_LANGID_CHINESE_GENERAL' : 0x0004,
+ 'TT_MS_LANGID_CHINESE_TAIWAN' : 0x0404,
+ 'TT_MS_LANGID_CHINESE_PRC' : 0x0804,
+ 'TT_MS_LANGID_CHINESE_HONG_KONG' : 0x0c04,
+ 'TT_MS_LANGID_CHINESE_SINGAPORE' : 0x1004,
+ 'TT_MS_LANGID_CHINESE_MACAU' : 0x1404,
+ 'TT_MS_LANGID_CZECH_CZECH_REPUBLIC' : 0x0405,
+ 'TT_MS_LANGID_DANISH_DENMARK' : 0x0406,
+ 'TT_MS_LANGID_GERMAN_GERMANY' : 0x0407,
+ 'TT_MS_LANGID_GERMAN_SWITZERLAND' : 0x0807,
+ 'TT_MS_LANGID_GERMAN_AUSTRIA' : 0x0c07,
+ 'TT_MS_LANGID_GERMAN_LUXEMBOURG' : 0x1007,
+ 'TT_MS_LANGID_GERMAN_LIECHTENSTEI' : 0x1407,
+ 'TT_MS_LANGID_GREEK_GREECE' : 0x0408,
+ 'TT_MS_LANGID_ENGLISH_GENERAL' : 0x0009,
+ 'TT_MS_LANGID_ENGLISH_UNITED_STATES' : 0x0409,
+ 'TT_MS_LANGID_ENGLISH_UNITED_KINGDOM' : 0x0809,
+ 'TT_MS_LANGID_ENGLISH_AUSTRALIA' : 0x0c09,
+ 'TT_MS_LANGID_ENGLISH_CANADA' : 0x1009,
+ 'TT_MS_LANGID_ENGLISH_NEW_ZEALAND' : 0x1409,
+ 'TT_MS_LANGID_ENGLISH_IRELAND' : 0x1809,
+ 'TT_MS_LANGID_ENGLISH_SOUTH_AFRICA' : 0x1c09,
+ 'TT_MS_LANGID_ENGLISH_JAMAICA' : 0x2009,
+ 'TT_MS_LANGID_ENGLISH_CARIBBEAN' : 0x2409,
+ 'TT_MS_LANGID_ENGLISH_BELIZE' : 0x2809,
+ 'TT_MS_LANGID_ENGLISH_TRINIDAD' : 0x2c09,
+ 'TT_MS_LANGID_ENGLISH_ZIMBABWE' : 0x3009,
+ 'TT_MS_LANGID_ENGLISH_PHILIPPINES' : 0x3409,
+ 'TT_MS_LANGID_ENGLISH_INDONESIA' : 0x3809,
+ 'TT_MS_LANGID_ENGLISH_HONG_KONG' : 0x3c09,
+ 'TT_MS_LANGID_ENGLISH_INDIA' : 0x4009,
+ 'TT_MS_LANGID_ENGLISH_MALAYSIA' : 0x4409,
+ 'TT_MS_LANGID_ENGLISH_SINGAPORE' : 0x4809,
+ 'TT_MS_LANGID_SPANISH_SPAIN_TRADITIONAL_SORT' : 0x040a,
+ 'TT_MS_LANGID_SPANISH_MEXICO' : 0x080a,
+ 'TT_MS_LANGID_SPANISH_SPAIN_INTERNATIONAL_SORT' : 0x0c0a,
+ 'TT_MS_LANGID_SPANISH_GUATEMALA' : 0x100a,
+ 'TT_MS_LANGID_SPANISH_COSTA_RICA' : 0x140a,
+ 'TT_MS_LANGID_SPANISH_PANAMA' : 0x180a,
+ 'TT_MS_LANGID_SPANISH_DOMINICAN_REPUBLIC' : 0x1c0a,
+ 'TT_MS_LANGID_SPANISH_VENEZUELA' : 0x200a,
+ 'TT_MS_LANGID_SPANISH_COLOMBIA' : 0x240a,
+ 'TT_MS_LANGID_SPANISH_PERU' : 0x280a,
+ 'TT_MS_LANGID_SPANISH_ARGENTINA' : 0x2c0a,
+ 'TT_MS_LANGID_SPANISH_ECUADOR' : 0x300a,
+ 'TT_MS_LANGID_SPANISH_CHILE' : 0x340a,
+ 'TT_MS_LANGID_SPANISH_URUGUAY' : 0x380a,
+ 'TT_MS_LANGID_SPANISH_PARAGUAY' : 0x3c0a,
+ 'TT_MS_LANGID_SPANISH_BOLIVIA' : 0x400a,
+ 'TT_MS_LANGID_SPANISH_EL_SALVADOR' : 0x440a,
+ 'TT_MS_LANGID_SPANISH_HONDURAS' : 0x480a,
+ 'TT_MS_LANGID_SPANISH_NICARAGUA' : 0x4c0a,
+ 'TT_MS_LANGID_SPANISH_PUERTO_RICO' : 0x500a,
+ 'TT_MS_LANGID_SPANISH_UNITED_STATES' : 0x540a,
+ 'TT_MS_LANGID_SPANISH_LATIN_AMERICA' : 0xE40a,
+ 'TT_MS_LANGID_FINNISH_FINLAND' : 0x040b,
+ 'TT_MS_LANGID_FRENCH_FRANCE' : 0x040c,
+ 'TT_MS_LANGID_FRENCH_BELGIUM' : 0x080c,
+ 'TT_MS_LANGID_FRENCH_CANADA' : 0x0c0c,
+ 'TT_MS_LANGID_FRENCH_SWITZERLAND' : 0x100c,
+ 'TT_MS_LANGID_FRENCH_LUXEMBOURG' : 0x140c,
+ 'TT_MS_LANGID_FRENCH_MONACO' : 0x180c,
+ 'TT_MS_LANGID_FRENCH_WEST_INDIES' : 0x1c0c,
+ 'TT_MS_LANGID_FRENCH_REUNION' : 0x200c,
+ 'TT_MS_LANGID_FRENCH_CONGO' : 0x240c,
+ 'TT_MS_LANGID_FRENCH_SENEGAL' : 0x280c,
+ 'TT_MS_LANGID_FRENCH_CAMEROON' : 0x2c0c,
+ 'TT_MS_LANGID_FRENCH_COTE_D_IVOIRE' : 0x300c,
+ 'TT_MS_LANGID_FRENCH_MALI' : 0x340c,
+ 'TT_MS_LANGID_FRENCH_MOROCCO' : 0x380c,
+ 'TT_MS_LANGID_FRENCH_HAITI' : 0x3c0c,
+ 'TT_MS_LANGID_FRENCH_NORTH_AFRICA' : 0xE40c,
+ 'TT_MS_LANGID_HEBREW_ISRAEL' : 0x040d,
+ 'TT_MS_LANGID_HUNGARIAN_HUNGARY' : 0x040e,
+ 'TT_MS_LANGID_ICELANDIC_ICELAND' : 0x040f,
+ 'TT_MS_LANGID_ITALIAN_ITALY' : 0x0410,
+ 'TT_MS_LANGID_ITALIAN_SWITZERLAND' : 0x0810,
+ 'TT_MS_LANGID_JAPANESE_JAPAN' : 0x0411,
+ 'TT_MS_LANGID_KOREAN_EXTENDED_WANSUNG_KOREA' : 0x0412,
+ 'TT_MS_LANGID_KOREAN_JOHAB_KOREA' : 0x0812,
+ 'TT_MS_LANGID_DUTCH_NETHERLANDS' : 0x0413,
+ 'TT_MS_LANGID_DUTCH_BELGIUM' : 0x0813,
+ 'TT_MS_LANGID_NORWEGIAN_NORWAY_BOKMAL' : 0x0414,
+ 'TT_MS_LANGID_NORWEGIAN_NORWAY_NYNORSK' : 0x0814,
+ 'TT_MS_LANGID_POLISH_POLAND' : 0x0415,
+ 'TT_MS_LANGID_PORTUGUESE_BRAZIL' : 0x0416,
+ 'TT_MS_LANGID_PORTUGUESE_PORTUGAL' : 0x0816,
+ 'TT_MS_LANGID_RHAETO_ROMANIC_SWITZERLAND' : 0x0417,
+ 'TT_MS_LANGID_ROMANIAN_ROMANIA' : 0x0418,
+ 'TT_MS_LANGID_MOLDAVIAN_MOLDAVIA' : 0x0818,
+ 'TT_MS_LANGID_RUSSIAN_RUSSIA' : 0x0419,
+ 'TT_MS_LANGID_RUSSIAN_MOLDAVIA' : 0x0819,
+ 'TT_MS_LANGID_CROATIAN_CROATIA' : 0x041a,
+ 'TT_MS_LANGID_SERBIAN_SERBIA_LATIN' : 0x081a,
+ 'TT_MS_LANGID_SERBIAN_SERBIA_CYRILLIC' : 0x0c1a,
+ 'TT_MS_LANGID_CROATIAN_BOSNIA_HERZEGOVINA' : 0x101a,
+ 'TT_MS_LANGID_BOSNIAN_BOSNIA_HERZEGOVINA' : 0x141a,
+ 'TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_LATIN' : 0x181a,
+ 'TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_CYRILLIC' : 0x181a,
+ 'TT_MS_LANGID_SLOVAK_SLOVAKIA' : 0x041b,
+ 'TT_MS_LANGID_ALBANIAN_ALBANIA' : 0x041c,
+ 'TT_MS_LANGID_SWEDISH_SWEDEN' : 0x041d,
+ 'TT_MS_LANGID_SWEDISH_FINLAND' : 0x081d,
+ 'TT_MS_LANGID_THAI_THAILAND' : 0x041e,
+ 'TT_MS_LANGID_TURKISH_TURKEY' : 0x041f,
+ 'TT_MS_LANGID_URDU_PAKISTAN' : 0x0420,
+ 'TT_MS_LANGID_URDU_INDIA' : 0x0820,
+ 'TT_MS_LANGID_INDONESIAN_INDONESIA' : 0x0421,
+ 'TT_MS_LANGID_UKRAINIAN_UKRAINE' : 0x0422,
+ 'TT_MS_LANGID_BELARUSIAN_BELARUS' : 0x0423,
+ 'TT_MS_LANGID_SLOVENE_SLOVENIA' : 0x0424,
+ 'TT_MS_LANGID_ESTONIAN_ESTONIA' : 0x0425,
+ 'TT_MS_LANGID_LATVIAN_LATVIA' : 0x0426,
+ 'TT_MS_LANGID_LITHUANIAN_LITHUANIA' : 0x0427,
+ 'TT_MS_LANGID_CLASSIC_LITHUANIAN_LITHUANIA' : 0x0827,
+ 'TT_MS_LANGID_TAJIK_TAJIKISTAN' : 0x0428,
+ 'TT_MS_LANGID_FARSI_IRAN' : 0x0429,
+ 'TT_MS_LANGID_VIETNAMESE_VIET_NAM' : 0x042a,
+ 'TT_MS_LANGID_ARMENIAN_ARMENIA' : 0x042b,
+ 'TT_MS_LANGID_AZERI_AZERBAIJAN_LATIN' : 0x042c,
+ 'TT_MS_LANGID_AZERI_AZERBAIJAN_CYRILLIC' : 0x082c,
+ 'TT_MS_LANGID_BASQUE_SPAIN' : 0x042d,
+ 'TT_MS_LANGID_SORBIAN_GERMANY' : 0x042e,
+ 'TT_MS_LANGID_MACEDONIAN_MACEDONIA' : 0x042f,
+ 'TT_MS_LANGID_SUTU_SOUTH_AFRICA' : 0x0430,
+ 'TT_MS_LANGID_TSONGA_SOUTH_AFRICA' : 0x0431,
+ 'TT_MS_LANGID_TSWANA_SOUTH_AFRICA' : 0x0432,
+ 'TT_MS_LANGID_VENDA_SOUTH_AFRICA' : 0x0433,
+ 'TT_MS_LANGID_XHOSA_SOUTH_AFRICA' : 0x0434,
+ 'TT_MS_LANGID_ZULU_SOUTH_AFRICA' : 0x0435,
+ 'TT_MS_LANGID_AFRIKAANS_SOUTH_AFRICA' : 0x0436,
+ 'TT_MS_LANGID_GEORGIAN_GEORGIA' : 0x0437,
+ 'TT_MS_LANGID_FAEROESE_FAEROE_ISLANDS' : 0x0438,
+ 'TT_MS_LANGID_HINDI_INDIA' : 0x0439,
+ 'TT_MS_LANGID_MALTESE_MALTA' : 0x043a,
+ 'TT_MS_LANGID_SAMI_NORTHERN_NORWAY' : 0x043b,
+ 'TT_MS_LANGID_SAMI_NORTHERN_SWEDEN' : 0x083b,
+ 'TT_MS_LANGID_SAMI_NORTHERN_FINLAND' : 0x0C3b,
+ 'TT_MS_LANGID_SAMI_LULE_NORWAY' : 0x103b,
+ 'TT_MS_LANGID_SAMI_LULE_SWEDEN' : 0x143b,
+ 'TT_MS_LANGID_SAMI_SOUTHERN_NORWAY' : 0x183b,
+ 'TT_MS_LANGID_SAMI_SOUTHERN_SWEDEN' : 0x1C3b,
+ 'TT_MS_LANGID_SAMI_SKOLT_FINLAND' : 0x203b,
+ 'TT_MS_LANGID_SAMI_INARI_FINLAND' : 0x243b,
+ 'TT_MS_LANGID_SAAMI_LAPONIA' : 0x043b,
+ 'TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM' : 0x083c,
+ 'TT_MS_LANGID_IRISH_GAELIC_IRELAND' : 0x043c,
+ 'TT_MS_LANGID_YIDDISH_GERMANY' : 0x043d,
+ 'TT_MS_LANGID_MALAY_MALAYSIA' : 0x043e,
+ 'TT_MS_LANGID_MALAY_BRUNEI_DARUSSALAM' : 0x083e,
+ 'TT_MS_LANGID_KAZAK_KAZAKSTAN' : 0x043f,
+ 'TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN' : 0x0440,
+ 'TT_MS_LANGID_KIRGHIZ_KIRGHIZ_REPUBLIC' : 0x0440,
+ 'TT_MS_LANGID_SWAHILI_KENYA' : 0x0441,
+ 'TT_MS_LANGID_TURKMEN_TURKMENISTAN' : 0x0442,
+ 'TT_MS_LANGID_UZBEK_UZBEKISTAN_LATIN' : 0x0443,
+ 'TT_MS_LANGID_UZBEK_UZBEKISTAN_CYRILLIC' : 0x0843,
+ 'TT_MS_LANGID_TATAR_TATARSTAN' : 0x0444,
+ 'TT_MS_LANGID_BENGALI_INDIA' : 0x0445,
+ 'TT_MS_LANGID_BENGALI_BANGLADESH' : 0x0845,
+ 'TT_MS_LANGID_PUNJABI_INDIA' : 0x0446,
+ 'TT_MS_LANGID_PUNJABI_ARABIC_PAKISTAN' : 0x0846,
+ 'TT_MS_LANGID_GUJARATI_INDIA' : 0x0447,
+ 'TT_MS_LANGID_ORIYA_INDIA' : 0x0448,
+ 'TT_MS_LANGID_TAMIL_INDIA' : 0x0449,
+ 'TT_MS_LANGID_TELUGU_INDIA' : 0x044a,
+ 'TT_MS_LANGID_KANNADA_INDIA' : 0x044b,
+ 'TT_MS_LANGID_MALAYALAM_INDIA' : 0x044c,
+ 'TT_MS_LANGID_ASSAMESE_INDIA' : 0x044d,
+ 'TT_MS_LANGID_MARATHI_INDIA' : 0x044e,
+ 'TT_MS_LANGID_SANSKRIT_INDIA' : 0x044f,
+ 'TT_MS_LANGID_MONGOLIAN_MONGOLIA' : 0x0450,
+ 'TT_MS_LANGID_MONGOLIAN_MONGOLIA_MONGOLIAN' : 0x0850,
+ 'TT_MS_LANGID_TIBETAN_CHINA' : 0x0451,
+ 'TT_MS_LANGID_DZONGHKA_BHUTAN' : 0x0851,
+ 'TT_MS_LANGID_TIBETAN_BHUTAN' : 0x0851,
+ 'TT_MS_LANGID_WELSH_WALES' : 0x0452,
+ 'TT_MS_LANGID_KHMER_CAMBODIA' : 0x0453,
+ 'TT_MS_LANGID_LAO_LAOS' : 0x0454,
+ 'TT_MS_LANGID_BURMESE_MYANMAR' : 0x0455,
+ 'TT_MS_LANGID_GALICIAN_SPAIN' : 0x0456,
+ 'TT_MS_LANGID_KONKANI_INDIA' : 0x0457,
+ 'TT_MS_LANGID_MANIPURI_INDIA' : 0x0458,
+ 'TT_MS_LANGID_SINDHI_INDIA' : 0x0459,
+ 'TT_MS_LANGID_SINDHI_PAKISTAN' : 0x0859,
+ 'TT_MS_LANGID_SYRIAC_SYRIA' : 0x045a,
+ 'TT_MS_LANGID_SINHALESE_SRI_LANKA' : 0x045b,
+ 'TT_MS_LANGID_CHEROKEE_UNITED_STATES' : 0x045c,
+ 'TT_MS_LANGID_INUKTITUT_CANADA' : 0x045d,
+ 'TT_MS_LANGID_AMHARIC_ETHIOPIA' : 0x045e,
+ 'TT_MS_LANGID_TAMAZIGHT_MOROCCO' : 0x045f,
+ 'TT_MS_LANGID_TAMAZIGHT_MOROCCO_LATIN' : 0x085f,
+ 'TT_MS_LANGID_KASHMIRI_PAKISTAN' : 0x0460,
+ 'TT_MS_LANGID_KASHMIRI_SASIA' : 0x0860,
+ 'TT_MS_LANGID_KASHMIRI_INDIA' : 0x0860,
+ 'TT_MS_LANGID_NEPALI_NEPAL' : 0x0461,
+ 'TT_MS_LANGID_NEPALI_INDIA' : 0x0861,
+ 'TT_MS_LANGID_FRISIAN_NETHERLANDS' : 0x0462,
+ 'TT_MS_LANGID_PASHTO_AFGHANISTAN' : 0x0463,
+ 'TT_MS_LANGID_FILIPINO_PHILIPPINES' : 0x0464,
+ 'TT_MS_LANGID_DHIVEHI_MALDIVES' : 0x0465,
+ 'TT_MS_LANGID_DIVEHI_MALDIVES' : 0x0465,
+ 'TT_MS_LANGID_EDO_NIGERIA' : 0x0466,
+ 'TT_MS_LANGID_FULFULDE_NIGERIA' : 0x0467,
+ 'TT_MS_LANGID_HAUSA_NIGERIA' : 0x0468,
+ 'TT_MS_LANGID_IBIBIO_NIGERIA' : 0x0469,
+ 'TT_MS_LANGID_YORUBA_NIGERIA' : 0x046a,
+ 'TT_MS_LANGID_QUECHUA_BOLIVIA' : 0x046b,
+ 'TT_MS_LANGID_QUECHUA_ECUADOR' : 0x086b,
+ 'TT_MS_LANGID_QUECHUA_PERU' : 0x0c6b,
+ 'TT_MS_LANGID_SEPEDI_SOUTH_AFRICA' : 0x046c,
+ 'TT_MS_LANGID_SOTHO_SOUTHERN_SOUTH_AFRICA' : 0x046c,
+ 'TT_MS_LANGID_IGBO_NIGERIA' : 0x0470,
+ 'TT_MS_LANGID_KANURI_NIGERIA' : 0x0471,
+ 'TT_MS_LANGID_OROMO_ETHIOPIA' : 0x0472,
+ 'TT_MS_LANGID_TIGRIGNA_ETHIOPIA' : 0x0473,
+ 'TT_MS_LANGID_TIGRIGNA_ERYTHREA' : 0x0873,
+ 'TT_MS_LANGID_TIGRIGNA_ERYTREA' : 0x0873,
+ 'TT_MS_LANGID_GUARANI_PARAGUAY' : 0x0474,
+ 'TT_MS_LANGID_HAWAIIAN_UNITED_STATES' : 0x0475,
+ 'TT_MS_LANGID_LATIN' : 0x0476,
+ 'TT_MS_LANGID_SOMALI_SOMALIA' : 0x0477,
+ 'TT_MS_LANGID_YI_CHINA' : 0x0478,
+ 'TT_MS_LANGID_PAPIAMENTU_NETHERLANDS_ANTILLES' : 0x0479,
+ 'TT_MS_LANGID_UIGHUR_CHINA' : 0x0480,
+ 'TT_MS_LANGID_MAORI_NEW_ZEALAND' : 0x0481 }
+globals().update(TT_MS_LANGIDS)
+
diff --git a/third_party/freetype-py/freetype/ft_enums/tt_name_ids.py b/third_party/freetype-py/freetype/ft_enums/tt_name_ids.py
new file mode 100644
index 0000000..c49a128
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/tt_name_ids.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+
+"""
+Possible values of the 'name' identifier field in the name records of the TTF
+'name' table. These values are platform independent.
+
+TT_NAME_ID_COPYRIGHT
+
+TT_NAME_ID_FONT_FAMILY
+
+TT_NAME_ID_FONT_SUBFAMILY
+
+TT_NAME_ID_UNIQUE_ID
+
+TT_NAME_ID_FULL_NAME
+
+TT_NAME_ID_VERSION_STRING
+
+TT_NAME_ID_PS_NAME
+
+TT_NAME_ID_TRADEMARK
+
+TT_NAME_ID_MANUFACTURER
+
+TT_NAME_ID_DESIGNER
+
+TT_NAME_ID_DESCRIPTION
+
+TT_NAME_ID_VENDOR_URL
+
+TT_NAME_ID_DESIGNER_URL
+
+TT_NAME_ID_LICENSE
+
+TT_NAME_ID_LICENSE_URL
+
+TT_NAME_ID_PREFERRED_FAMILY
+
+TT_NAME_ID_PREFERRED_SUBFAMILY
+
+TT_NAME_ID_MAC_FULL_NAME
+
+TT_NAME_ID_SAMPLE_TEXT
+
+TT_NAME_ID_CID_FINDFONT_NAME
+
+TT_NAME_ID_WWS_FAMILY
+
+TT_NAME_ID_WWS_SUBFAMILY
+"""
+
+
+TT_NAME_IDS = {
+ 'TT_NAME_ID_COPYRIGHT' : 0,
+ 'TT_NAME_ID_FONT_FAMILY' : 1,
+ 'TT_NAME_ID_FONT_SUBFAMILY' : 2,
+ 'TT_NAME_ID_UNIQUE_ID' : 3,
+ 'TT_NAME_ID_FULL_NAME' : 4,
+ 'TT_NAME_ID_VERSION_STRING' : 5,
+ 'TT_NAME_ID_PS_NAME' : 6,
+ 'TT_NAME_ID_TRADEMARK' : 7,
+
+ # the following values are from the OpenType spec
+ 'TT_NAME_ID_MANUFACTURER' : 8,
+ 'TT_NAME_ID_DESIGNER' : 9,
+ 'TT_NAME_ID_DESCRIPTION' : 10,
+ 'TT_NAME_ID_VENDOR_URL' : 11,
+ 'TT_NAME_ID_DESIGNER_URL' : 12,
+ 'TT_NAME_ID_LICENSE' : 13,
+ 'TT_NAME_ID_LICENSE_URL' : 14,
+ # number 15 is reserved
+ 'TT_NAME_ID_PREFERRED_FAMILY' : 16,
+ 'TT_NAME_ID_PREFERRED_SUBFAMILY' : 17,
+ 'TT_NAME_ID_MAC_FULL_NAME' : 18,
+
+ # The following code is new as of 2000-01-21
+ 'TT_NAME_ID_SAMPLE_TEXT' : 19,
+
+ # This is new in OpenType 1.3
+ 'TT_NAME_ID_CID_FINDFONT_NAME' : 20,
+
+ # This is new in OpenType 1.5
+ 'TT_NAME_ID_WWS_FAMILY' : 21,
+ 'TT_NAME_ID_WWS_SUBFAMILY' : 22 }
+globals().update(TT_NAME_IDS)
+
diff --git a/third_party/freetype-py/freetype/ft_enums/tt_platforms.py b/third_party/freetype-py/freetype/ft_enums/tt_platforms.py
new file mode 100644
index 0000000..7b3c397
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_enums/tt_platforms.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011-2012 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+"""
+A list of valid values for the 'platform_id' identifier code in FT_CharMapRec
+and FT_SfntName structures.
+
+
+TT_PLATFORM_APPLE_UNICODE
+
+ Used by Apple to indicate a Unicode character map and/or name entry. See
+ TT_APPLE_ID_XXX for corresponding 'encoding_id' values. Note that name
+ entries in this format are coded as big-endian UCS-2 character codes only.
+
+
+TT_PLATFORM_MACINTOSH
+
+ Used by Apple to indicate a MacOS-specific charmap and/or name entry. See
+ TT_MAC_ID_XXX for corresponding 'encoding_id' values. Note that most TrueType
+ fonts contain an Apple roman charmap to be usable on MacOS systems (even if
+ they contain a Microsoft charmap as well).
+
+
+TT_PLATFORM_ISO
+
+ This value was used to specify ISO/IEC 10646 charmaps. It is however now
+ deprecated. See TT_ISO_ID_XXX for a list of corresponding 'encoding_id'
+ values.
+
+
+TT_PLATFORM_MICROSOFT
+
+ Used by Microsoft to indicate Windows-specific charmaps. See TT_MS_ID_XXX for
+ a list of corresponding 'encoding_id' values. Note that most fonts contain a
+ Unicode charmap using (TT_PLATFORM_MICROSOFT, TT_MS_ID_UNICODE_CS).
+
+
+TT_PLATFORM_CUSTOM
+
+ Used to indicate application-specific charmaps.
+
+
+TT_PLATFORM_ADOBE
+
+ This value isn't part of any font format specification, but is used by
+ FreeType to report Adobe-specific charmaps in an FT_CharMapRec structure. See
+ TT_ADOBE_ID_XXX.
+"""
+
+TT_PLATFORMS = {
+ 'TT_PLATFORM_APPLE_UNICODE' : 0,
+ 'TT_PLATFORM_MACINTOSH' : 1,
+ 'TT_PLATFORM_ISO' : 2, # deprecated
+ 'TT_PLATFORM_MICROSOFT' : 3,
+ 'TT_PLATFORM_CUSTOM' : 4,
+ 'TT_PLATFORM_ADOBE' : 7} # artificial
+globals().update(TT_PLATFORMS)
+
diff --git a/third_party/freetype-py/freetype/ft_errors.py b/third_party/freetype-py/freetype/ft_errors.py
new file mode 100644
index 0000000..04ccebc
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_errors.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+'''
+Internal exception with freetype error message
+'''
+class FT_Exception(Exception):
+ def __init__(self, errcode, message=''):
+ self.message = message
+ self.errcode = errcode
+
+ def __str__(self):
+ return '%s: %s (%s)'%(self.__class__.__name__, self.message,
+ self._errors.get(self.errcode, 'unknown error'))
+
+ _errors = {
+ 0x00: "no error" ,
+ 0x01: "cannot open resource" ,
+ 0x02: "unknown file format" ,
+ 0x03: "broken file" ,
+ 0x04: "invalid FreeType version" ,
+ 0x05: "module version is too low" ,
+ 0x06: "invalid argument" ,
+ 0x07: "unimplemented feature" ,
+ 0x08: "broken table" ,
+ 0x09: "broken offset within table" ,
+ 0x10: "invalid glyph index" ,
+ 0x11: "invalid character code" ,
+ 0x12: "unsupported glyph image format" ,
+ 0x13: "cannot render this glyph format" ,
+ 0x14: "invalid outline" ,
+ 0x15: "invalid composite glyph" ,
+ 0x16: "too many hints" ,
+ 0x17: "invalid pixel size" ,
+ 0x20: "invalid object handle" ,
+ 0x21: "invalid library handle" ,
+ 0x22: "invalid module handle" ,
+ 0x23: "invalid face handle" ,
+ 0x24: "invalid size handle" ,
+ 0x25: "invalid glyph slot handle" ,
+ 0x26: "invalid charmap handle" ,
+ 0x27: "invalid cache manager handle" ,
+ 0x28: "invalid stream handle" ,
+ 0x30: "too many modules" ,
+ 0x31: "too many extensions" ,
+ 0x40: "out of memory" ,
+ 0x41: "unlisted object" ,
+ 0x51: "cannot open stream" ,
+ 0x52: "invalid stream seek" ,
+ 0x53: "invalid stream skip" ,
+ 0x54: "invalid stream read" ,
+ 0x55: "invalid stream operation" ,
+ 0x56: "invalid frame operation" ,
+ 0x57: "nested frame access" ,
+ 0x58: "invalid frame read" ,
+ 0x60: "raster uninitialized" ,
+ 0x61: "raster corrupted" ,
+ 0x62: "raster overflow" ,
+ 0x63: "negative height while rastering" ,
+ 0x70: "too many registered caches" ,
+ 0x80: "invalid opcode" ,
+ 0x81: "too few arguments" ,
+ 0x82: "stack overflow" ,
+ 0x83: "code overflow" ,
+ 0x84: "bad argument" ,
+ 0x85: "division by zero" ,
+ 0x86: "invalid reference" ,
+ 0x87: "found debug opcode" ,
+ 0x88: "found ENDF opcode in execution stream" ,
+ 0x89: "nested DEFS" ,
+ 0x8A: "invalid code range" ,
+ 0x8B: "execution context too long" ,
+ 0x8C: "too many function definitions" ,
+ 0x8D: "too many instruction definitions" ,
+ 0x8E: "SFNT font table missing" ,
+ 0x8F: "horizontal header (hhea, table missing" ,
+ 0x90: "locations (loca, table missing" ,
+ 0x91: "name table missing" ,
+ 0x92: "character map (cmap, table missing" ,
+ 0x93: "horizontal metrics (hmtx, table missing" ,
+ 0x94: "PostScript (post, table missing" ,
+ 0x95: "invalid horizontal metrics" ,
+ 0x96: "invalid character map (cmap, format" ,
+ 0x97: "invalid ppem value" ,
+ 0x98: "invalid vertical metrics" ,
+ 0x99: "could not find context" ,
+ 0x9A: "invalid PostScript (post, table format" ,
+ 0x9B: "invalid PostScript (post, table" ,
+ 0xA0: "opcode syntax error" ,
+ 0xA1: "argument stack underflow" ,
+ 0xA2: "ignore" ,
+ 0xB0: "`STARTFONT' field missing" ,
+ 0xB1: "`FONT' field missing" ,
+ 0xB2: "`SIZE' field missing" ,
+ 0xB3: "`CHARS' field missing" ,
+ 0xB4: "`STARTCHAR' field missing" ,
+ 0xB5: "`ENCODING' field missing" ,
+ 0xB6: "`BBX' field missing" ,
+ 0xB7: "`BBX' too big" ,
+ }
diff --git a/third_party/freetype-py/freetype/ft_structs.py b/third_party/freetype-py/freetype/ft_structs.py
new file mode 100644
index 0000000..c669c92
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_structs.py
@@ -0,0 +1,944 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+'''
+Freetype structured types
+-------------------------
+
+FT_Library: A handle to a FreeType library instance.
+
+FT_Vector: A simple structure used to store a 2D vector.
+
+FT_BBox: A structure used to hold an outline's bounding box.
+
+FT_Matrix: A simple structure used to store a 2x2 matrix.
+
+FT_UnitVector: A simple structure used to store a 2D vector unit vector.
+
+FT_Bitmap: A structure used to describe a bitmap or pixmap to the raster.
+
+FT_Data: Read-only binary data represented as a pointer and a length.
+
+FT_Generic: Client applications generic data.
+
+FT_Bitmap_Size: Metrics of a bitmap strike.
+
+FT_Charmap: The base charmap structure.
+
+FT_Glyph_Metrics:A structure used to model the metrics of a single glyph.
+
+FT_Outline: This structure is used to describe an outline to the scan-line
+ converter.
+
+FT_GlyphSlot: FreeType root glyph slot class structure.
+
+FT_Glyph: The root glyph structure contains a given glyph image plus its
+ advance width in 16.16 fixed float format.
+
+FT_Size_Metrics: The size metrics structure gives the metrics of a size object.
+
+FT_Size: FreeType root size class structure.
+
+FT_Face: FreeType root face class structure.
+
+FT_Parameter: A simple structure used to pass more or less generic parameters
+ to FT_Open_Face.
+
+FT_Open_Args: A structure used to indicate how to open a new font file or
+ stream.
+
+FT_SfntName: A structure used to model an SFNT 'name' table entry.
+
+FT_Stroker: Opaque handler to a path stroker object.
+
+FT_BitmapGlyph: A structure used for bitmap glyph images.
+'''
+from freetype.ft_types import *
+
+
+# -----------------------------------------------------------------------------
+# A handle to a FreeType library instance. Each 'library' is completely
+# independent from the others; it is the 'root' of a set of objects like fonts,
+# faces, sizes, etc.
+class FT_LibraryRec(Structure):
+ '''
+ A handle to a FreeType library instance. Each 'library' is completely
+ independent from the others; it is the 'root' of a set of objects like
+ fonts, faces, sizes, etc.
+ '''
+ _fields_ = [ ]
+FT_Library = POINTER(FT_LibraryRec)
+
+
+
+# -----------------------------------------------------------------------------
+# A simple structure used to store a 2D vector; coordinates are of the FT_Pos
+# type.
+class FT_Vector(Structure):
+ '''
+ A simple structure used to store a 2D vector; coordinates are of the FT_Pos
+ type.
+
+ x: The horizontal coordinate.
+ y: The vertical coordinate.
+ '''
+ _fields_ = [('x', FT_Pos),
+ ('y', FT_Pos)]
+
+
+
+# -----------------------------------------------------------------------------
+# A structure used to hold an outline's bounding box, i.e., the coordinates of
+# its extrema in the horizontal and vertical directions.
+#
+# The bounding box is specified with the coordinates of the lower left and the
+# upper right corner. In PostScript, those values are often called (llx,lly)
+# and (urx,ury), respectively.
+#
+# If 'yMin' is negative, this value gives the glyph's descender. Otherwise, the
+# glyph doesn't descend below the baseline. Similarly, if 'ymax' is positive,
+# this value gives the glyph's ascender.
+#
+# 'xMin' gives the horizontal distance from the glyph's origin to the left edge
+# of the glyph's bounding box. If 'xMin' is negative, the glyph extends to the
+# left of the origin.
+class FT_BBox(Structure):
+ '''
+ A structure used to hold an outline's bounding box, i.e., the coordinates
+ of its extrema in the horizontal and vertical directions.
+
+ The bounding box is specified with the coordinates of the lower left and
+ the upper right corner. In PostScript, those values are often called
+ (llx,lly) and (urx,ury), respectively.
+
+ If 'yMin' is negative, this value gives the glyph's descender. Otherwise,
+ the glyph doesn't descend below the baseline. Similarly, if 'ymax' is
+ positive, this value gives the glyph's ascender.
+
+ 'xMin' gives the horizontal distance from the glyph's origin to the left
+ edge of the glyph's bounding box. If 'xMin' is negative, the glyph extends
+ to the left of the origin.
+
+ xMin: The horizontal minimum (left-most).
+ yMin: The vertical minimum (bottom-most).
+ xMax: The horizontal maximum (right-most).
+ yMax: The vertical maximum (top-most).
+ '''
+ _fields_ = [('xMin', FT_Pos),
+ ('yMin', FT_Pos),
+ ('xMax', FT_Pos),
+ ('yMax', FT_Pos)]
+
+
+
+# -----------------------------------------------------------------------------
+# A simple structure used to store a 2x2 matrix. Coefficients are in 16.16
+# fixed float format. The computation performed is:
+# x' = x*xx + y*xy
+# y' = x*yx + y*yy
+class FT_Matrix(Structure):
+ '''
+ A simple structure used to store a 2x2 matrix. Coefficients are in 16.16
+ fixed float format. The computation performed is:
+
+ x' = x*xx + y*xy
+ y' = x*yx + y*yy
+
+ xx: Matrix coefficient.
+ xy: Matrix coefficient.
+ yx: Matrix coefficient.
+ yy: Matrix coefficient.
+ '''
+ _fields_ = [('xx', FT_Fixed),
+ ('xy', FT_Fixed),
+ ('yx', FT_Fixed),
+ ('yy', FT_Fixed)]
+
+
+
+# -----------------------------------------------------------------------------
+# A simple structure used to store a 2D vector unit vector. Uses FT_F2Dot14
+# types.
+class FT_UnitVector(Structure):
+ '''
+ A simple structure used to store a 2D vector unit vector. Uses FT_F2Dot14
+ types.
+
+ x: The horizontal coordinate.
+ y: The vertical coordinate.
+ '''
+ _fields_ = [('x', FT_F2Dot14),
+ ('y', FT_F2Dot14)]
+
+
+
+# -----------------------------------------------------------------------------
+# A structure used to describe a bitmap or pixmap to the raster. Note that we
+# now manage pixmaps of various depths through the 'pixel_mode' field.
+class FT_Bitmap(Structure):
+ '''
+ A structure used to describe a bitmap or pixmap to the raster. Note that we
+ now manage pixmaps of various depths through the 'pixel_mode' field.
+
+ rows: The number of bitmap rows.
+
+ width: The number of pixels in bitmap row.
+
+ pitch: The pitch's absolute value is the number of bytes taken by one
+ bitmap row, including padding. However, the pitch is positive when
+ the bitmap has a 'down' flow, and negative when it has an 'up'
+ flow. In all cases, the pitch is an offset to add to a bitmap
+ pointer in order to go down one row.
+
+ Note that 'padding' means the alignment of a bitmap to a byte
+ border, and FreeType functions normally align to the smallest
+ possible integer value.
+
+ For the B/W rasterizer, 'pitch' is always an even number.
+
+ To change the pitch of a bitmap (say, to make it a multiple of 4),
+ use FT_Bitmap_Convert. Alternatively, you might use callback
+ functions to directly render to the application's surface; see the
+ file 'example2.py' in the tutorial for a demonstration.
+
+ buffer: A typeless pointer to the bitmap buffer. This value should be
+ aligned on 32-bit boundaries in most cases.
+
+ num_grays: This field is only used with FT_PIXEL_MODE_GRAY; it gives the
+ number of gray levels used in the bitmap.
+
+ pixel_mode: The pixel mode, i.e., how pixel bits are stored. See
+ FT_Pixel_Mode for possible values.
+
+ palette_mode: This field is intended for paletted pixel modes; it indicates
+ how the palette is stored. Not used currently.
+
+ palette: A typeless pointer to the bitmap palette; this field is intended
+ for paletted pixel modes. Not used currently.
+ '''
+ _fields_ = [
+ ('rows', c_int),
+ ('width', c_int),
+ ('pitch', c_int),
+ # declaring buffer as c_char_p confuses ctypes
+ ('buffer', POINTER(c_ubyte)),
+ ('num_grays', c_short),
+ ('pixel_mode', c_ubyte),
+ ('palette_mode', c_char),
+ ('palette', c_void_p) ]
+
+
+
+# -----------------------------------------------------------------------------
+# Read-only binary data represented as a pointer and a length.
+class FT_Data(Structure):
+ '''
+ Read-only binary data represented as a pointer and a length.
+
+ pointer: The data.
+ length: The length of the data in bytes.
+ '''
+ _fields_ = [('pointer', POINTER(FT_Byte)),
+ ('y', FT_Int)]
+
+
+
+# -----------------------------------------------------------------------------
+# Client applications often need to associate their own data to a variety of
+# FreeType core objects. For example, a text layout API might want to associate
+# a glyph cache to a given size object.
+#
+# Most FreeType object contains a 'generic' field, of type FT_Generic, which
+# usage is left to client applications and font servers.
+#
+# It can be used to store a pointer to client-specific data, as well as the
+# address of a 'finalizer' function, which will be called by FreeType when the
+# object is destroyed (for example, the previous client example would put the
+# address of the glyph cache destructor in the 'finalizer' field).
+class FT_Generic(Structure):
+ '''
+ Client applications often need to associate their own data to a variety of
+ FreeType core objects. For example, a text layout API might want to
+ associate a glyph cache to a given size object.
+
+ Most FreeType object contains a 'generic' field, of type FT_Generic, which
+ usage is left to client applications and font servers.
+
+ It can be used to store a pointer to client-specific data, as well as the
+ address of a 'finalizer' function, which will be called by FreeType when
+ the object is destroyed (for example, the previous client example would put
+ the address of the glyph cache destructor in the 'finalizer' field).
+
+ data: A typeless pointer to any client-specified data. This field is
+ completely ignored by the FreeType library.
+ finalizer: A pointer to a 'generic finalizer' function, which will be
+ called when the object is destroyed. If this field is set to
+ NULL, no code will be called.
+ '''
+ _fields_ = [('data', c_void_p),
+ ('finalizer', FT_Generic_Finalizer)]
+
+
+
+
+# -----------------------------------------------------------------------------
+# This structure models the metrics of a bitmap strike (i.e., a set of glyphs
+# for a given point size and resolution) in a bitmap font. It is used for the
+# 'available_sizes' field of FT_Face.
+class FT_Bitmap_Size(Structure):
+ '''
+ This structure models the metrics of a bitmap strike (i.e., a set of glyphs
+ for a given point size and resolution) in a bitmap font. It is used for the
+ 'available_sizes' field of FT_Face.
+
+ height: The vertical distance, in pixels, between two consecutive
+ baselines. It is always positive.
+
+ width: The average width, in pixels, of all glyphs in the strike.
+
+ size: The nominal size of the strike in 26.6 fractional points. This field
+ is not very useful.
+
+ x_ppem: The horizontal ppem (nominal width) in 26.6 fractional pixels.
+
+ y_ppem: The vertical ppem (nominal height) in 26.6 fractional pixels.
+ '''
+ _fields_ = [
+ ('height', FT_Short),
+ ('width', FT_Short),
+ ('size', FT_Pos),
+ ('x_ppem', FT_Pos),
+ ('y_ppem', FT_Pos) ]
+
+
+
+# -----------------------------------------------------------------------------
+# The base charmap structure.
+class FT_CharmapRec(Structure):
+ '''
+ The base charmap structure.
+
+ face : A handle to the parent face object.
+
+ encoding : An FT_Encoding tag identifying the charmap. Use this with
+ FT_Select_Charmap.
+
+ platform_id: An ID number describing the platform for the following
+ encoding ID. This comes directly from the TrueType
+ specification and should be emulated for other formats.
+
+ encoding_id: A platform specific encoding number. This also comes from the
+ TrueType specification and should be emulated similarly.
+ '''
+ _fields_ = [
+ ('face', c_void_p), # Shoudl be FT_Face
+ ('encoding', FT_Encoding),
+ ('platform_id', FT_UShort),
+ ('encoding_id', FT_UShort),
+ ]
+FT_Charmap = POINTER(FT_CharmapRec)
+
+
+
+# -----------------------------------------------------------------------------
+# A structure used to model the metrics of a single glyph. The values are
+# expressed in 26.6 fractional pixel format; if the flag FT_LOAD_NO_SCALE has
+# been used while loading the glyph, values are expressed in font units
+# instead.
+class FT_Glyph_Metrics(Structure):
+ '''
+ A structure used to model the metrics of a single glyph. The values are
+ expressed in 26.6 fractional pixel format; if the flag FT_LOAD_NO_SCALE has
+ been used while loading the glyph, values are expressed in font units
+ instead.
+
+ width: The glyph's width.
+
+ height: The glyph's height.
+
+ horiBearingX: Left side bearing for horizontal layout.
+
+ horiBearingY: Top side bearing for horizontal layout.
+
+ horiAdvance: Advance width for horizontal layout.
+
+ vertBearingX: Left side bearing for vertical layout.
+
+ vertBearingY: Top side bearing for vertical layout.
+
+ vertAdvance: Advance height for vertical layout.
+ '''
+ _fields_ = [
+ ('width', FT_Pos),
+ ('height', FT_Pos),
+ ('horiBearingX', FT_Pos),
+ ('horiBearingY', FT_Pos),
+ ('horiAdvance', FT_Pos),
+ ('vertBearingX', FT_Pos),
+ ('vertBearingY', FT_Pos),
+ ('vertAdvance', FT_Pos),
+ ]
+
+
+
+# -----------------------------------------------------------------------------
+# This structure is used to describe an outline to the scan-line converter.
+class FT_Outline(Structure):
+ '''
+ This structure is used to describe an outline to the scan-line converter.
+
+ n_contours: The number of contours in the outline.
+
+ n_points: The number of points in the outline.
+
+ points: A pointer to an array of 'n_points' FT_Vector elements, giving the
+ outline's point coordinates.
+
+ tags: A pointer to an array of 'n_points' chars, giving each outline
+ point's type.
+
+ If bit 0 is unset, the point is 'off' the curve, i.e., a Bezier
+ control point, while it is 'on' if set.
+
+ Bit 1 is meaningful for 'off' points only. If set, it indicates a
+ third-order Bezier arc control point; and a second-order control
+ point if unset.
+
+ If bit 2 is set, bits 5-7 contain the drop-out mode (as defined in
+ the OpenType specification; the value is the same as the argument to
+ the SCANMODE instruction).
+
+ Bits 3 and 4 are reserved for internal purposes.
+
+ contours: An array of 'n_contours' shorts, giving the end point of each
+ contour within the outline. For example, the first contour is
+ defined by the points '0' to 'contours[0]', the second one is
+ defined by the points 'contours[0]+1' to 'contours[1]', etc.
+
+ flags: A set of bit flags used to characterize the outline and give hints
+ to the scan-converter and hinter on how to convert/grid-fit it. See
+ FT_OUTLINE_FLAGS.
+ '''
+ _fields_ = [
+ ('n_contours', c_short),
+ ('n_points', c_short),
+ ('points', POINTER(FT_Vector)),
+ # declaring buffer as c_char_p would prevent us to acces all tags
+ ('tags', POINTER(c_ubyte)),
+ ('contours', POINTER(c_short)),
+ ('flags', c_int),
+ ]
+
+
+# -----------------------------------------------------------------------------
+# The root glyph structure contains a given glyph image plus its advance width
+# in 16.16 fixed float format.
+
+class FT_GlyphRec(Structure):
+ '''
+ The root glyph structure contains a given glyph image plus its advance
+ width in 16.16 fixed float format.
+
+ library: A handle to the FreeType library object.
+
+ clazz: A pointer to the glyph's class. Private.
+
+ format: The format of the glyph's image.
+
+ advance: A 16.16 vector that gives the glyph's advance width.
+ '''
+ _fields_ = [
+ ('library', FT_Library),
+ ('clazz', c_void_p),
+ ('format', FT_Glyph_Format),
+ ('advance', FT_Vector)
+ ]
+FT_Glyph = POINTER(FT_GlyphRec)
+
+
+
+# -----------------------------------------------------------------------------
+# FreeType root glyph slot class structure. A glyph slot is a container where
+# individual glyphs can be loaded, be they in outline or bitmap format.
+class FT_GlyphSlotRec(Structure):
+ '''
+ FreeType root glyph slot class structure. A glyph slot is a container where
+ individual glyphs can be loaded, be they in outline or bitmap format.
+
+ library: A handle to the FreeType library instance this slot belongs to.
+
+ face: A handle to the parent face object.
+
+ next: In some cases (like some font tools), several glyph slots per face
+ object can be a good thing. As this is rare, the glyph slots are
+ listed through a direct, single-linked list using its 'next' field.
+
+ generic: A typeless pointer which is unused by the FreeType library or any
+ of its drivers. It can be used by client applications to link
+ their own data to each glyph slot object.
+
+ metrics: The metrics of the last loaded glyph in the slot. The returned
+ values depend on the last load flags (see the FT_Load_Glyph API
+ function) and can be expressed either in 26.6 fractional pixels or
+ font units.
+
+ Note that even when the glyph image is transformed, the metrics
+ are not.
+
+ linearHoriAdvance: The advance width of the unhinted glyph. Its value is
+ expressed in 16.16 fractional pixels, unless
+ FT_LOAD_LINEAR_DESIGN is set when loading the
+ glyph. This field can be important to perform correct
+ WYSIWYG layout. Only relevant for outline glyphs.
+
+ linearVertAdvance: The advance height of the unhinted glyph. Its value is
+ expressed in 16.16 fractional pixels, unless
+ FT_LOAD_LINEAR_DESIGN is set when loading the
+ glyph. This field can be important to perform correct
+ WYSIWYG layout. Only relevant for outline glyphs.
+
+ advance: This shorthand is, depending on FT_LOAD_IGNORE_TRANSFORM, the
+ transformed advance width for the glyph (in 26.6 fractional pixel
+ format). As specified with FT_LOAD_VERTICAL_LAYOUT, it uses either
+ the 'horiAdvance' or the 'vertAdvance' value of 'metrics' field.
+
+ format: This field indicates the format of the image contained in the glyph
+ slot. Typically FT_GLYPH_FORMAT_BITMAP, FT_GLYPH_FORMAT_OUTLINE, or
+ FT_GLYPH_FORMAT_COMPOSITE, but others are possible.
+
+ bitmap: This field is used as a bitmap descriptor when the slot format is
+ FT_GLYPH_FORMAT_BITMAP. Note that the address and content of the
+ bitmap buffer can change between calls of FT_Load_Glyph and a few
+ other functions.
+
+ bitmap_left: This is the bitmap's left bearing expressed in integer
+ pixels. Of course, this is only valid if the format is
+ FT_GLYPH_FORMAT_BITMAP.
+
+ bitmap_top: This is the bitmap's top bearing expressed in integer
+ pixels. Remember that this is the distance from the baseline to
+ the top-most glyph scanline, upwards y coordinates being
+ positive.
+
+ outline: The outline descriptor for the current glyph image if its format
+ is FT_GLYPH_FORMAT_OUTLINE. Once a glyph is loaded, 'outline' can
+ be transformed, distorted, embolded, etc. However, it must not be
+ freed.
+
+ num_subglyphs: The number of subglyphs in a composite glyph. This field is
+ only valid for the composite glyph format that should
+ normally only be loaded with the FT_LOAD_NO_RECURSE
+ flag. For now this is internal to FreeType.
+
+ subglyphs: An array of subglyph descriptors for composite glyphs. There are
+ 'num_subglyphs' elements in there. Currently internal to
+ FreeType.
+
+ control_data: Certain font drivers can also return the control data for a
+ given glyph image (e.g. TrueType bytecode, Type 1
+ charstrings, etc.). This field is a pointer to such data.
+
+ control_len: This is the length in bytes of the control data.
+
+ other: Really wicked formats can use this pointer to present their own
+ glyph image to client applications. Note that the application needs
+ to know about the image format.
+
+ lsb_delta: The difference between hinted and unhinted left side bearing
+ while autohinting is active. Zero otherwise.
+
+ rsb_delta: The difference between hinted and unhinted right side bearing
+ while autohinting is active. Zero otherwise.
+ '''
+ _fields_ = [
+ ('library', FT_Library),
+ ('face', c_void_p),
+ ('next', c_void_p),
+ ('reserved', c_uint),
+ ('generic', FT_Generic),
+
+ ('metrics', FT_Glyph_Metrics),
+ ('linearHoriAdvance', FT_Fixed),
+ ('linearVertAdvance', FT_Fixed),
+ ('advance', FT_Vector),
+
+ ('format', FT_Glyph_Format),
+
+ ('bitmap', FT_Bitmap),
+ ('bitmap_left', FT_Int),
+ ('bitmap_top', FT_Int),
+
+ ('outline', FT_Outline),
+ ('num_subglyphs', FT_UInt),
+ ('subglyphs', c_void_p),
+
+ ('control_data', c_void_p),
+ ('control_len', c_long),
+
+ ('lsb_delta', FT_Pos),
+ ('rsb_delta', FT_Pos),
+ ('other', c_void_p),
+ ('internal', c_void_p),
+ ]
+FT_GlyphSlot = POINTER(FT_GlyphSlotRec)
+
+
+
+# -----------------------------------------------------------------------------
+# The size metrics structure gives the metrics of a size object.
+class FT_Size_Metrics(Structure):
+ '''
+ The size metrics structure gives the metrics of a size object.
+
+ x_ppem: The width of the scaled EM square in pixels, hence the term 'ppem'
+ (pixels per EM). It is also referred to as 'nominal width'.
+
+ y_ppem: The height of the scaled EM square in pixels, hence the term 'ppem'
+ (pixels per EM). It is also referred to as 'nominal height'.
+
+ x_scale: A 16.16 fractional scaling value used to convert horizontal
+ metrics from font units to 26.6 fractional pixels. Only relevant
+ for scalable font formats.
+
+ y_scale: A 16.16 fractional scaling value used to convert vertical metrics
+ from font units to 26.6 fractional pixels. Only relevant for
+ scalable font formats.
+
+ ascender: The ascender in 26.6 fractional pixels. See FT_FaceRec for the
+ details.
+
+ descender: The descender in 26.6 fractional pixels. See FT_FaceRec for the
+ details.
+
+ height: The height in 26.6 fractional pixels. See FT_FaceRec for the
+ details.
+
+ max_advance: The maximal advance width in 26.6 fractional pixels. See
+ FT_FaceRec for the details.
+ '''
+ _fields_ = [
+ ('x_ppem', FT_UShort),
+ ('y_ppem', FT_UShort),
+
+ ('x_scale', FT_Fixed),
+ ('y_scale', FT_Fixed),
+
+ ('ascender', FT_Pos),
+ ('descender', FT_Pos),
+ ('height', FT_Pos),
+ ('max_advance', FT_Pos),
+ ]
+
+
+
+# -----------------------------------------------------------------------------
+# FreeType root size class structure. A size object models a face object at a
+# given size.
+class FT_SizeRec(Structure):
+ '''
+ FreeType root size class structure. A size object models a face object at a
+ given size.
+
+ face: Handle to the parent face object.
+
+ generic: A typeless pointer, which is unused by the FreeType library or any
+ of its drivers. It can be used by client applications to link
+ their own data to each size object.
+
+ metrics: Metrics for this size object. This field is read-only.
+ '''
+ _fields_ = [
+ ('face', c_void_p),
+ ('generic', FT_Generic),
+ ('metrics', FT_Size_Metrics),
+ ('internal', c_void_p),
+ ]
+FT_Size = POINTER(FT_SizeRec)
+
+
+
+# -----------------------------------------------------------------------------
+# FreeType root face class structure. A face object models a typeface in a font
+# file.
+class FT_FaceRec(Structure):
+ '''
+ FreeType root face class structure. A face object models a typeface in a
+ font file.
+
+ num_faces: The number of faces in the font file. Some font formats can have
+ multiple faces in a font file.
+
+ face_index: The index of the face in the font file. It is set to 0 if there
+ is only one face in the font file.
+
+ face_flags: A set of bit flags that give important information about the
+ face; see FT_FACE_FLAG_XXX for the details.
+
+ style_flags: A set of bit flags indicating the style of the face; see
+ FT_STYLE_FLAG_XXX for the details.
+
+ num_glyphs: The number of glyphs in the face. If the face is scalable and
+ has sbits (see 'num_fixed_sizes'), it is set to the number of
+ outline glyphs.
+
+ For CID-keyed fonts, this value gives the highest CID used in
+ the font.
+
+ family_name: The face's family name. This is an ASCII string, usually in
+ English, which describes the typeface's family (like 'Times
+ New Roman', 'Bodoni', 'Garamond', etc). This is a least common
+ denominator used to list fonts. Some formats (TrueType &
+ OpenType) provide localized and Unicode versions of this
+ string. Applications should use the format specific interface
+ to access them. Can be NULL (e.g., in fonts embedded in a PDF
+ file).
+
+ style_name: The face's style name. This is an ASCII string, usually in
+ English, which describes the typeface's style (like 'Italic',
+ 'Bold', 'Condensed', etc). Not all font formats provide a style
+ name, so this field is optional, and can be set to NULL. As for
+ 'family_name', some formats provide localized and Unicode
+ versions of this string. Applications should use the format
+ specific interface to access them.
+
+ num_fixed_sizes: The number of bitmap strikes in the face. Even if the face
+ is scalable, there might still be bitmap strikes, which
+ are called 'sbits' in that case.
+
+ available_sizes: An array of FT_Bitmap_Size for all bitmap strikes in the
+ face. It is set to NULL if there is no bitmap strike.
+
+ num_charmaps: The number of charmaps in the face.
+
+ charmaps: An array of the charmaps of the face.
+
+ generic: A field reserved for client uses. See the FT_Generic type
+ description.
+
+ bbox: The font bounding box. Coordinates are expressed in font units (see
+ 'units_per_EM'). The box is large enough to contain any glyph from
+ the font. Thus, 'bbox.yMax' can be seen as the 'maximal ascender',
+ and 'bbox.yMin' as the 'minimal descender'. Only relevant for
+ scalable formats.
+
+ Note that the bounding box might be off by (at least) one pixel for
+ hinted fonts. See FT_Size_Metrics for further discussion.
+
+ units_per_EM: The number of font units per EM square for this face. This is
+ typically 2048 for TrueType fonts, and 1000 for Type 1
+ fonts. Only relevant for scalable formats.
+
+ ascender: The typographic ascender of the face, expressed in font
+ units. For font formats not having this information, it is set to
+ 'bbox.yMax'. Only relevant for scalable formats.
+
+ descender: The typographic descender of the face, expressed in font
+ units. For font formats not having this information, it is set
+ to 'bbox.yMin'. Note that this field is usually negative. Only
+ relevant for scalable formats.
+
+ height: The height is the vertical distance between two consecutive
+ baselines, expressed in font units. It is always positive. Only
+ relevant for scalable formats.
+
+ max_advance_width: The maximal advance width, in font units, for all glyphs
+ in this face. This can be used to make word wrapping
+ computations faster. Only relevant for scalable formats.
+
+ max_advance_height: The maximal advance height, in font units, for all
+ glyphs in this face. This is only relevant for vertical
+ layouts, and is set to 'height' for fonts that do not
+ provide vertical metrics. Only relevant for scalable
+ formats.
+
+ underline_position: The position, in font units, of the underline line for
+ this face. It is the center of the underlining
+ stem. Only relevant for scalable formats.
+
+ underline_thickness: The thickness, in font units, of the underline for
+ this face. Only relevant for scalable formats.
+
+ glyph: The face's associated glyph slot(s).
+
+ size: The current active size for this face.
+
+ charmap: The current active charmap for this face.
+ '''
+ _fields_ = [
+ ('num_faces', FT_Long),
+ ('face_index', FT_Long),
+
+ ('face_flags', FT_Long),
+ ('style_flags', FT_Long),
+
+ ('num_glyphs', FT_Long),
+
+ ('family_name', FT_String_p),
+ ('style_name', FT_String_p),
+
+ ('num_fixed_sizes', FT_Int),
+ ('available_sizes', POINTER(FT_Bitmap_Size)),
+
+ ('num_charmaps', c_int),
+ ('charmaps', POINTER(FT_Charmap)),
+
+ ('generic', FT_Generic),
+
+ # The following member variables (down to `underline_thickness')
+ # are only relevant to scalable outlines; cf. @FT_Bitmap_Size
+ # for bitmap fonts.
+ ('bbox', FT_BBox),
+
+ ('units_per_EM', FT_UShort),
+ ('ascender', FT_Short),
+ ('descender', FT_Short),
+ ('height', FT_Short),
+
+ ('max_advance_width', FT_Short),
+ ('max_advance_height', FT_Short),
+
+ ('underline_position', FT_Short),
+ ('underline_thickness', FT_Short),
+
+ ('glyph', FT_GlyphSlot),
+ ('size', FT_Size),
+ ('charmap', FT_Charmap),
+
+ # private
+ ('driver', c_void_p),
+ ('memory', c_void_p),
+ ('stream', c_void_p),
+ ('sizes_list_head', c_void_p),
+ ('sizes_list_tail', c_void_p),
+ ('autohint', FT_Generic),
+ ('extensions', c_void_p),
+ ('internal', c_void_p),
+ ]
+FT_Face = POINTER(FT_FaceRec)
+
+
+
+# -----------------------------------------------------------------------------
+# A simple structure used to pass more or less generic parameters to
+# FT_Open_Face.
+class FT_Parameter(Structure):
+ '''
+ A simple structure used to pass more or less generic parameters to
+ FT_Open_Face.
+
+ tag: A four-byte identification tag.
+
+ data: A pointer to the parameter data
+ '''
+ _fields_ = [
+ ('tag', FT_ULong),
+ ('data', FT_Pointer) ]
+FT_Parameter_p = POINTER(FT_Parameter)
+
+
+
+# -----------------------------------------------------------------------------
+# A structure used to indicate how to open a new font file or stream. A pointer
+# to such a structure can be used as a parameter for the functions FT_Open_Face
+# and FT_Attach_Stream.
+class FT_Open_Args(Structure):
+ '''
+ A structure used to indicate how to open a new font file or stream. A pointer
+ to such a structure can be used as a parameter for the functions FT_Open_Face
+ and FT_Attach_Stream.
+
+ flags: A set of bit flags indicating how to use the structure.
+
+ memory_base: The first byte of the file in memory.
+
+ memory_size: The size in bytes of the file in memory.
+
+ pathname: A pointer to an 8-bit file pathname.
+
+ stream: A handle to a source stream object.
+
+ driver: This field is exclusively used by FT_Open_Face; it simply specifies
+ the font driver to use to open the face. If set to 0, FreeType
+ tries to load the face with each one of the drivers in its list.
+
+ num_params: The number of extra parameters.
+
+ params: Extra parameters passed to the font driver when opening a new face.
+ '''
+ _fields_ = [
+ ('flags', FT_UInt),
+ ('memory_base', POINTER(FT_Byte)),
+ ('memory_size', FT_Long),
+ ('pathname', FT_String_p),
+ ('stream', c_void_p),
+ ('driver', c_void_p),
+ ('num_params', FT_Int),
+ ('params', FT_Parameter_p) ]
+
+
+
+# -----------------------------------------------------------------------------
+# A structure used to model an SFNT 'name' table entry.
+
+class FT_SfntName(Structure):
+ '''
+ platform_id: The platform ID for 'string'.
+
+ encoding_id: The encoding ID for 'string'.
+
+ language_id: The language ID for 'string'
+
+ name_id: An identifier for 'string'
+
+ string: The 'name' string. Note that its format differs depending on the
+ (platform,encoding) pair. It can be a Pascal String, a UTF-16 one,
+ etc.
+
+ Generally speaking, the string is not zero-terminated. Please refer
+ to the TrueType specification for details.
+
+ string_len: The length of 'string' in bytes.
+ '''
+
+ _fields_ = [
+ ('platform_id', FT_UShort),
+ ('encoding_id', FT_UShort),
+ ('language_id', FT_UShort),
+ ('name_id', FT_UShort),
+ # this string is *not* null-terminated!
+ ('string', POINTER(FT_Byte)),
+ ('string_len', FT_UInt) ]
+
+
+
+# -----------------------------------------------------------------------------
+# Opaque handler to a path stroker object.
+class FT_StrokerRec(Structure):
+ '''
+ Opaque handler to a path stroker object.
+ '''
+ _fields_ = [ ]
+FT_Stroker = POINTER(FT_StrokerRec)
+
+
+# -----------------------------------------------------------------------------
+# A structure used for bitmap glyph images. This really is a 'sub-class' of
+# FT_GlyphRec.
+#
+class FT_BitmapGlyphRec(Structure):
+ '''
+ A structure used for bitmap glyph images. This really is a 'sub-class' of
+ FT_GlyphRec.
+ '''
+ _fields_ = [
+ ('root' , FT_GlyphRec),
+ ('left', FT_Int),
+ ('top', FT_Int),
+ ('bitmap', FT_Bitmap)
+ ]
+FT_BitmapGlyph = POINTER(FT_BitmapGlyphRec)
diff --git a/third_party/freetype-py/freetype/ft_types.py b/third_party/freetype-py/freetype/ft_types.py
new file mode 100644
index 0000000..8ae0f19
--- /dev/null
+++ b/third_party/freetype-py/freetype/ft_types.py
@@ -0,0 +1,155 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+#
+# FreeType high-level python API - Copyright 2011 Nicolas P. Rougier
+# Distributed under the terms of the new BSD license.
+#
+# -----------------------------------------------------------------------------
+'''
+Freetype basic data types
+-------------------------
+
+FT_Byte : A simple typedef for the unsigned char type.
+
+FT_Bytes : A typedef for constant memory areas.
+
+FT_Char : A simple typedef for the signed char type.
+
+FT_Int : A typedef for the int type.
+
+FT_UInt : A typedef for the unsigned int type.
+
+FT_Int16 : A typedef for a 16bit signed integer type.
+
+FT_UInt16 : A typedef for a 16bit unsigned integer type.
+
+FT_Int32 : A typedef for a 32bit signed integer type.
+
+FT_UInt32 : A typedef for a 32bit unsigned integer type.
+
+FT_Short : A typedef for signed short.
+
+FT_UShort : A typedef for unsigned short.
+
+FT_Long : A typedef for signed long.
+
+FT_ULong : A typedef for unsigned long.
+
+FT_Bool : A typedef of unsigned char, used for simple booleans. As usual,
+ values 1 and 0 represent true and false, respectively.
+
+FT_Offset : This is equivalent to the ANSI C 'size_t' type, i.e., the largest
+ unsigned integer type used to express a file size or position, or
+ a memory block size.
+
+FT_PtrDist : This is equivalent to the ANSI C 'ptrdiff_t' type, i.e., the
+ largest signed integer type used to express the distance between
+ two pointers.
+
+FT_String : A simple typedef for the char type, usually used for strings.
+
+FT_Tag : A typedef for 32-bit tags (as used in the SFNT format).
+
+FT_Error : The FreeType error code type. A value of 0 is always interpreted as
+ a successful operation.
+
+FT_Fixed : This type is used to store 16.16 fixed float values, like scaling
+ values or matrix coefficients.
+
+FT_Pointer : A simple typedef for a typeless pointer.
+
+FT_Pos : The type FT_Pos is used to store vectorial coordinates. Depending on
+ the context, these can represent distances in integer font units, or
+ 16.16, or 26.6 fixed float pixel coordinates.
+
+FT_FWord : A signed 16-bit integer used to store a distance in original font
+ units.
+
+FT_UFWord : An unsigned 16-bit integer used to store a distance in original
+ font units.
+
+FT_F2Dot14 : A signed 2.14 fixed float type used for unit vectors.
+
+FT_F26Dot6 : A signed 26.6 fixed float type used for vectorial pixel
+ coordinates.
+'''
+from ctypes import *
+
+
+FT_Byte = c_ubyte # A simple typedef for the unsigned char type.
+
+FT_Bytes = c_char_p # A typedef for constant memory areas.
+
+FT_Char = c_char # A simple typedef for the signed char type.
+
+FT_Int = c_int # A typedef for the int type.
+
+FT_UInt = c_uint # A typedef for the unsigned int type.
+
+FT_Int16 = c_short # A typedef for a 16bit signed integer type.
+
+FT_UInt16 = c_ushort # A typedef for a 16bit unsigned integer type.
+
+FT_Int32 = c_int32 # A typedef for a 32bit signed integer type.
+
+FT_UInt32 = c_uint32 # A typedef for a 32bit unsigned integer type.
+
+FT_Short = c_short # A typedef for signed short.
+
+FT_UShort = c_ushort # A typedef for unsigned short.
+
+FT_Long = c_long # A typedef for signed long.
+
+FT_ULong = c_ulong # A typedef for unsigned long.
+
+FT_Bool = c_char # A typedef of unsigned char, used for simple booleans. As
+ # usual, values 1 and 0 represent true and false,
+ # respectively.
+
+FT_Offset = c_size_t # This is equivalent to the ANSI C 'size_t' type, i.e.,
+ # the largest unsigned integer type used to express a file
+ # size or position, or a memory block size.
+
+FT_PtrDist = c_longlong # This is equivalent to the ANSI C 'ptrdiff_t' type,
+ # i.e., the largest signed integer type used to express
+ # the distance between two pointers.
+
+FT_String = c_char # A simple typedef for the char type, usually used for strings.
+
+FT_String_p= c_char_p
+
+FT_Tag = FT_UInt32 # A typedef for 32-bit tags (as used in the SFNT format).
+
+FT_Error = c_int # The FreeType error code type. A value of 0 is always
+ # interpreted as a successful operation.
+
+FT_Fixed = c_long # This type is used to store 16.16 fixed float values,
+ # like scaling values or matrix coefficients.
+
+FT_Pointer = c_void_p # A simple typedef for a typeless pointer.
+
+FT_Pos = c_long # The type FT_Pos is used to store vectorial
+ # coordinates. Depending on the context, these can
+ # represent distances in integer font units, or 16.16, or
+ # 26.6 fixed float pixel coordinates.
+
+FT_FWord = c_short # A signed 16-bit integer used to store a distance in
+ # original font units.
+
+FT_UFWord = c_ushort # An unsigned 16-bit integer used to store a distance in
+ # original font units.
+
+FT_F2Dot14 = c_short # A signed 2.14 fixed float type used for unit vectors.
+
+FT_F26Dot6 = c_long # A signed 26.6 fixed float type used for vectorial pixel
+ # coordinates.
+
+FT_Glyph_Format = c_int
+
+FT_Encoding = c_int
+
+
+# Describe a function used to destroy the 'client' data of any FreeType
+# object. See the description of the FT_Generic type for details of usage.
+FT_Generic_Finalizer = CFUNCTYPE(None, c_void_p)