`typerig.proxy.objects.glyph`

typerig.proxy.objects.glyph (version 0.26.9)

# MODULE: Typerig / Proxy / Glyph
# -----------------------------------------------------------
# (C) Vassil Kateliev, 2017-2020        (http://www.kateliev.com)
# (C) Karandash Type Foundry            (http://www.karandash.eu)
#------------------------------------------------------------
# www.typerig.com

Modules

fontgate
fontlab
math
PythonQt
fontTools.pens.statisticsPen

Classes

class eGlyph(pGlyph)

Extended representation of the Proxy Glyph, adding some advanced functionality

Constructor:
        pGlyph() - default represents the current glyph and current font
        pGlyph(fgFont, fgGlyph)

Method resolution order:: eGlyph; pGlyph; builtin.object

Methods

bindCompMetrics(self, layer=None, bindIndex=None)

Auto bind metrics to the base composite glyph or to specified shape index

blendLayers(self, layerA, layerB, blendTimes, outputFL=True, blendMode=0, engine='fg')

Blend two layers at given times (anisotropic support).
Args:
        layerA (flLayer), layerB (flLayer): Shapes to be interpolated
        blendTimes (int or float or tuple(float, float)): (int) for percent 0%-100% or (float) time for both X,Y or tuple(float,float) times for anisotropic blending
        outputFL (bool): Return blend native format or flShape (default)
        blendMode (int): ?
        engine (str): 'fg' for FontGate (in-build).

Returns:
        flLayer

breakContour(self, contourId, nodeId, layer=None, expand=0)

Split Contour at given node and layer. Extrapolate line endings if needed.
Args:
        contourId (int): Contour Index
        nodeId (int): Node Index
        layer (int or str): Layer index or name, works with both
        expand (float): Will extrapolate the line endings at that given value

Returns:
        flContour

copyADVbyName(self, glyphName, layers=None, adjustPercent=100, adjustUnits=0)

Copy Advance width from another glyph specified by Glyph Name.

Args:
        glyphName (str): Name of source glyph
        layers tuple(bool): Bool control tuple(active_layer, masters, masks, services). Note If all are set to False only the active layer is used.
        adjustPercent (int): Adjust the copied metric by percent (100 default)
        adjustUnits (int): Adjust the copied metric by units (0 default)

Return:
        None

copyLSBbyName(self, glyphName, layers=None, order=0, adjustPercent=100, adjustUnits=0)

Copy LSB from another glyph specified by Glyph Name.

Args:
        glyphName (str): Name of source glyph
        layers tuple(bool): Bool control tuple(active_layer, masters, masks, services). Note If all are set to False only the active layer is used.
        order (bool or int): Use source LSB (0 False) or RSB (1 True). Flips the metric copied.
        adjustPercent (int): Adjust the copied metric by percent (100 default)
        adjustUnits (int): Adjust the copied metric by units (0 default)

Return:
        None

copyMetricsbyName(self, metricTriple=(None, None, None), layers=None, order=(0, 0, 0), adjustPercent=(100, 100, 100), adjustUnits=(0, 0, 0))

Copy LSB, RSB and Advance width from glyphs specified by Glyph Name.

Args:
        metricTriple tuple(str): Names of source glyphs for (LSB, RSB, ADV)
        layers tuple(bool): Bool control tuple(active_layer, masters, masks, services). Note If all are set to False only the active layer is used.
        order tuple(bool): Use source LSB (0 False) or RSB (1 True). Flips the metric copied. (LSB, RSB, 0)
        adjustPercent tuple(int): Adjust the copied metric by percent (100 default) - (LSB, RSB, ADV)
        adjustUnits tuple(int): Adjust the copied metric by units (0 default) - (LSB, RSB, ADV)

Return:
        None

copyRSBbyName(self, glyphName, layers=None, order=0, adjustPercent=100, adjustUnits=0)

Copy RSB from another glyph specified by Glyph Name.

Args:
        glyphName (str): Name of source glyph
        layers tuple(bool): Bool control tuple(active_layer, masters, masks, services). Note If all are set to False only the active layer is used.
        order (bool or int): Use source LSB (0 False) or RSB (1 True). Flips the metric copied.
        adjustPercent (int): Adjust the copied metric by percent (100 default)
        adjustUnits (int): Adjust the copied metric by units (0 default)

Return:
        None

dropAnchor(self, name, layer, coordTuple, alignTuple=(None, None), tolerance=5, italic=False)

Drop anchor at given layer
Args:
        name (str): Anchor Name
        layer (int or str): Layer index or name, works with both
        coordTuple (int, int): New anchor coordinates or auto aligment offsets*
        alignTuple (str,str): New anchor aligment*
        tolerance (int): Outline feature auto detection tolerance*

*Aligment rules: (width, height)
        - (None,None) - Uses coordinates given
        - width - (L) Left; (R) Right; (A) Auto Bottom with tolerance; (AT) Auto Top with tolerance; (C) Center;
        - height - (T) Top; (B) Bottom; (C) Center;
Returns:
        None

dropGuide(self, nodes=None, layers=None, name='*DropGuideline', tag='', color='darkMagenta', flip=(1, 1), style='gsGlyphGuideline')

Build guideline trough *any two* given points or the *first two of the current selection*.

If *single point* is given will create a vertical guideline trough that point,
with guideline inclined according to the font's Italic Angle.

if process layers (pLayers) is None guideline will be created in all compatible layers,
otherwise the bool control tuple (active_layer (True or False), masters (True or False), masks (True or False), services (True or False)) is used. 
If all are set to False only the active layer is used.

Args:
        nodes (list(int)): List of node indexes
        layers tuple(bool): Bool control tuple(active_layer, masters, masks, services). Note If all are set to False only the active layer is used.
        name (str): Name of the guideline to be build
        color (str): Color of the guideline according to QtCore colors
        style (str): Style of the guideline according to FontLab 6

Returns:
        None

getAttachmentCenters(self, layer, tolerance=5, applyTransform=True, getAll=False)

Return X center of lowest, highest Y of [glyph] for [layer] within given [tolerance]
Note: Determine diacritic to glyph attachment positions (for anchor placement)

getNewBaseCoords(self, layer, adjustTuple, alignTuple, tolerance=5, italic=False, initPosTuple=(0.0, 0.0))

Calculate Anchor base position
Args:
        layer (int or str): Layer index or name, works with both
        coordTuple (int/float, int/float): New anchor coordinates or auto aligment offsets*
        alignTuple (str,str): New anchor aligment*
        tolerance (int/float): Outline feature auto detection tolerance*
        initPosTuple (int/float, int/float): Itinital anchor position

*Aligment rules: (width, height)
        - (None,None) - Uses coordinates given
        - width - (L) Left; (R) Right; (A) Auto Bottom with tolerance; (AT) Auto Top with tolerance; (C) Center;
        - height - (T) Top; (B) Bottom; (C) Center;
Returns:
        x, y (int/float)

lerpLayerFg(self, l0_Name, l1_Name)

moveAnchor(self, name, layer, coordTuple=(0, 0), alignTuple=(None, None), tolerance=5, italic=False)

Move anchor at given layer
Args:
        name (str): Anchor Name
        layer (int or str): Layer index or name, works with both
        coordTuple (int, int): New anchor coordinates or auto aligment offsets*
        alignTuple (str,str): New anchor aligment*
        tolerance (int): Outline feature auto detection tolerance*

*Aligment rules: (width, height)
        - (None,None) - Uses coordinates given
        - width - (L) Left; (R) Right; (A) Auto Bottom with tolerance; (AT) Auto Top with tolerance; (C) Center;
        - height - (T) Top; (B) Bottom; (C) Center;
Returns:
        None

reorder_shapes(self, layer=None, mode=(0, 0))

Auto reorder shapes on given layer using criteria.
Args:
        layer (int or str): Layer index or name, works with both
        mode (bool, bool): Mode of shape reordering/sorting by (X, Y)

Returns:
        None

setStart(self, layer=None, control=(0, 0))

splitContour(self, scnPairs=None, layers=None, expand=0, close=False)

Split Contour at given node and combinations of compatible layers. Extrapolate line endings and close contour if needed.

Args:
        scnPairs (list(tuple)): Shape-contour-node pairs for the selected nodes [(Shape Index, Contour Index, Node Index)..()]
        layers tuple(bool): Bool control tuple(active_layer, masters, masks, services). Note If all are set to False only the active layer is used.
        expand (float): Will extrapolate the line endings at that given value
        close (bool): True = Close contour 

Return:
        None

ungroup_all_shapes(self, layer=None, applyTransform=True)

Ungroup all shapes at given layer.
Args:
        layer (int or str): Layer index or name, works with both
        applyTransform (bool): Apply transformation at shape.

Returns:
        None

Methods from pGlyph

init(self, *argv)

repr(self)

activeGuides(self)

activeLayer(self)

addAnchor(self, coordTuple, name, layer=None, isAnchor=True)

Adds named Anchor at given layer.
Args:
        coordTuple (tuple(float,float)): Anchor coordinates X, Y
        name (str): Anchor name
        layer (int or str): Layer index or name. If None returns ActiveLayer
        isAnchor (bool): True creates a true flAnchor, False ? (flPinPoint)
Returns:
        None

addComponents(self, componentConfig, layer=None, useAnchors=True, colorize=False)

Adds a components to given glyph layer.
Args:
        componentConfig (list(tuple(glyph_name (str), glyph_transform (QTransform), layer_pointer (str)))): List contianign component configuration.  
        layer (int or str): Layer index or name. If None returns ActiveLayer
        useAnchors (bool): Compose using anchors
        colorize (bool): Flag new glyphs
Returns:
        list(flShapes): List of components added

addGuideline(self, coordTuple, layer=None, angle=0, name='', tag='', color='darkMagenta', style='gsGlyphGuideline')

Adds named Guideline at given layer
Args:
        coordTuple (tuple(float,float) or tuple(float,float,float,float)): Guideline coordinates X, Y and given angle or two node reference x1,y1 and x2,y2
        name (str): Anchor name
        angle (float): Incline of the guideline
        layer (int or str): Layer index or name. If None returns ActiveLayer                    
Returns:
        None

addLayer(self, layer, toBack=False)

Adds a layer to glyph.
Args:
        layer (flLayer or fgLayer)
        toBack (bool): Send layer to back
Returns:
        None

addShape(self, shape, layer=None, clone=False)

Add a new shape at given layer.
Args:
        shape (flShape): Shape to be added
Returns:
        flShape

addShapeContainer(self, shapeList, layer=None, remove=True)

Add a new shape container* at given layer.
A flShape containing all of the shapes given that
could be transformed to Shape-group or shape-filter.
Args:
        shapeList list(flShape): List if Shapes to be grouped.
Returns:
        flShape

anchors(self, layer=None)

Return list of anchors (list[flAnchor]) at given layer (int or str)

blendShapes(self, shapeA, shapeB, blendTimes, outputFL=True, blendMode=0, engine='fg')

Blend two shapes at given times (anisotropic support).
Args:
        shapeA (flShape), shapeB (flShape): Shapes to be interpolated
        blendTimes (int or float or tuple(float, float)): (int) for percent 0%-100% or (float) time for both X,Y or tuple(float,float) times for anisotropic blending
        outputFL (bool): Return blend native format or flShape (default)
        blendMode (int): ?
        engine (str): 'fg' for FontGate (in-build).

Returns:
        Native (interpolation engine dependent) or flShape (default)

clearAnchors(self, layer=None)

Remove all anchors at given layer (int or str)

components(self, layer=None, extend=None)

Return all glyph components besides glyph.

containers(self, layer=None, extend=None)

Return all complex shapes that contain other shapes at given layer.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[flShapes]

contours(self, layer=None, deep=True, extend=None)

Return all contours at given layer.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[flContours]

copyLayer(self, srcLayerName, dstLayerName, options={'adv': True, 'anc': True, 'gui': True, 'lnk': True, 'lsb': True, 'out': True, 'ref': True, 'rsb': True}, addLayer=False, cleanDST=True, toBack=True)

Copies a layer within the glyph.
Args:
        srcLayerName, dstLayerName (string): Source and destination layer names
        options (dict): Copy Options as follows {'out': Outline, 'gui': Guidelines, 'anc': Anchors, 'lsb': LSB, 'adv': Advance, 'rsb': RSB, 'lnk': Linked metrics, 'ref': References}, addLayer=False):
        addLayer (bool): Create a new layer
        cleanDST (bool): Clean destination layer
        toBack (bool): Add layer to back of the layer stack
Returns:
        flLayer

decompose(self, layer=None)

Decompose all complex shapes that contain other shapes at given layer.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        None

dereference(self, layer=None)

Remove all shape references but leave components.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[flShapes]

draw(self, pen, layer=None)

Utilizes the Pen protocol

drawPoints(self, pen, layer=None)

Utilizes the PointPen protocol

duplicateLayer(self, layer=None, newLayerName='New Layer', references=False)

Duplicates a layer with new name and adds it to glyph's layers.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
        toBack(bool): send to back
Returns:
        flLayer

elements(self, layer=None, extend=None)

Return all glyph elements in glyph

fg_activeLayer(self)

fg_contours(self, layer=None)

Return all FontGate contours at given layer.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[fgContours]

fg_hasLayer(self, layerName)

fg_layer(self, layer=None)

Returns FontGate layer no matter the reference.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        fgLayer

fg_layers(self, asDict=False)

Return all FotnGate layers

fg_nodes(self, layer=None)

Return all FontGate nodes at given layer.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[fgNodes]

fg_shapes(self, layer=None)

Return all FontGate shapes at given layer.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[fgShapes]

findAnchor(self, anchorName, layer=None)

Find anchor by name/tag

findAnchorCoords(self, anchorName, layer=None)

Find anchor coordinates by name/tag

findNode(self, nodeName, layer=None)

Find node by name/tag

findNodeCoords(self, nodeName, layer=None)

Find node coordinates by name/tag

findShape(self, shapeName, layer=None)

Finds shape by name on given layer
Args:
        shapeName (str): Shape name
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        flShape or None

fontMetricsInfo(self, layer=None)

Returns Font(layer) metrics no matter the reference.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        FontMetrics (object)

getAdvance(self, layer=None)

Get the Advance Width at given layer (int or str)

getBounds(self, layer=None)

Get Glyph's Boundig Box at given layer (int or str). Returns QRectF.

getBuilders(self, layer=None, store=False)

getCompositionDict(self, layer=None)

Return composition dict of a glyph. Elements!

getCompositionNames(self, layer=None)

Return name of glyph and the parts it is made of.

getElementNames(self, layer=None)

Return names of elements references used in glyph.

getLSB(self, layer=None)

Get the Left Side-bearing at given layer (int or str)

getRSB(self, layer=None)

Get the Right Side-bearing at given layer (int or str)

getSBeq(self, layer=None)

GET LSB, RSB metric equations on given layer

getSegment(self, cID, nID, layer=None)

Returns contour segment of the node specified at given layer
Args:
        cID (int): Contour index
        nID (int): Node of insertion index
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        CurveEx

getTags(self)

# - Tags -----------------------------------------------

guidelines(self, layer=None)

Return list of guidelines (list[flGuideline]) at given layer (int or str)

hasLayer(self, layerName)

insertNodeAt(self, cID, nID_time, layer=None)

Inserts node in contour at specified layer
Arg:
        cID (int): Contour Index
        nID_time (float): Node index + float time
        layer (int or str): Layer index or name. If None returns ActiveLayer

!NOTE: FL6 treats contour insertions (as well as nodes) as float times along contour,
so inserting a node at .5 t between nodes with indexes 3 and 4 will be 3 (index) + 0.5 (time) = 3.5

insertNodesAt(self, cID, nID, nodeList, layer=None)

Inserts a list of nodes to specified contour, starting at given index all on layer specified.
Args:
        cID (int): Contour index
        nID (int): Node of insertion index
        nodeList (list): List of flNode objects
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        None

isCompatible(self, strong=False)

Test if glyph is ready for interpolation - all master layers are compatible.

isMixedReference(self)

Test if glyph has mixed references - components on some layers and referenced shapes on others

italicAngle(self)

layer(self, layer=None)

Returns layer no matter the reference.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        flLayer

layers(self)

Return all layers

mLine(self)

mapNodes2Times(self, layer=None)

Create map of Nodes at contour times for every contour in given layer
Returns:
        dict{Contour index (int) : dict{Contour Time (int): Node Index (int) }}

mapTimes2Nodes(self, layer=None)

Create map of Contour times at node indexes for every contour in given layer
Returns:
        dict{Contour index (int) : dict{Node Index (int) : Contour Time (int) }}

mask(self)

masks(self)

Returns all mask layers.

masters(self)

Returns all master layers.

newAnchor(self, coordTuple, name, anchorType=1)

Not working

nodes(self, layer=None, extend=None, deep=False)

Return all nodes at given layer.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer.
        extend (class): A class construct with extended functionality to be applied on every node.
Returns:
        list[flNodes]

nodes4segments(self, cID, layer=None)

Returns all contour segments and their corresponding nodes at given layer
Args:
        cID (int): Contour index
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        dict{time(int):(CurveEx, list[flNode]}

nodesForIndices(self, indices, layer=None, filterOn=False, extend=None, deep=False)

noncomplex(self, layer=None, extend=None)

Return all glyph shapes that are not glyph references or components

object(self)

removeLayer(self, layer)

Removes a layer from glyph.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        None

removeNodeAt(self, cID, nID, layer=None)

Removes a node from contour at layer specified.
Args:
        cID (int): Contour index
        nID (int): Index of Node to be removed
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        None

removeNodes(self, cID, nodeList, layer=None)

Removes a list of nodes from contour at layer specified.
Args:
        cID (int): Contour index
        nodeList (list): List of flNode objects
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        None

removeShape(self, shape, layer=None, recursive=True)

Remove a new shape at given layer.
Args:
        old_shape, new_shape (flShape): Shapes
        layer (str): Layer name
        recursive (bool): 
Returns:
        None

replaceShape(self, old_shape, new_shape, layer=None)

Repalce a shape at given layer.
Args:
        old_shape, new_shape (flShape): Shapes
        layer (str): Layer name
Returns:
        None

reportLayerComp(self, strong=False)

Returns a layer compatibility report

rotate(self, deg, layer=None)

Rotate outline at given layer.
Args:
        deg (float): degrees of slant
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        None

scale(self, sx, sy, layer=None)

Scale outline at given layer.
Args:
        sx (float), sy (float): delta (scaling) X, Y
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        None

segments(self, cID, layer=None)

Returns all contour segments at given layer
Args:
        cID (int): Contour index
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[CurveEx]

selected(self, filterOn=False, deep=False)

Return all selected nodes indexes at current layer.
Args:
        filterOn (bool): Return only on-curve nodes
Returns:
        list[int]

selectedAtContours(self, index=True, layer=None, filterOn=False, deep=False)

Return all selected nodes and the contours they rest upon at current layer.
Args:
        index (bool): If True returns only indexes, False returns flContour, flNode
        filterOn (bool): Return only on-curve nodes
Returns:
        list[tuple(int, int)]: [(contourID, nodeID)..()] or 
        list[tuple(flContour, flNode)]

selectedAtShapes(self, index=True, filterOn=False, layer=None, deep=False)

Return all selected nodes and the shapes they belong at current layer.
Args:
        index (bool): If True returns only indexes, False returns flShape, flNode
        filterOn (bool): Return only on-curve nodes
Returns:
        list[tuple(int, int)]: [(shapeID, nodeID)..()] or
        list[tuple(flShape, flNode)]

!TODO: Make it working with layers as selectedAtContours(). This is legacy mode so other scripts would work!

selectedContours(self, layer=None, allNodesSelected=False)

selectedCoords(self, layer=None, filterOn=False, applyTransform=False)

Return the coordinates of all selected nodes at the current layer or other.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
        filterOn (bool): Return only on-curve nodes
        applyTransform (bool) : Gets local shape transformation matrix and applies it to the node coordinates
Returns:
        list[QPointF]

selectedNodeIndices(self, filterOn=False, deep=False)

Return all indices of nodes selected at current layer.
Args:
        filterOn (bool): Return only on-curve nodes
Returns:
        list[int]

selectedNodes(self, layer=None, filterOn=False, extend=None, deep=False)

Return all selected nodes at given layer.
Args:
        filterOn (bool): Return only on-curve nodes
        extend (class): A class construct with extended functionality to be applied on every node.
Returns:
        list[flNode]

selectedNodesOnCanvas(self, filterOn=False)

# - Glyph Selection -----------------------------------------------

selectedSegments(self, layer=None)

Returns list of currently selected segments
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[CurveEx]

selectedShapeIndices(self, select_all=False, deep=False)

Return all indices of nodes selected at current layer.
Args:
        select_all (bool): True all nodes on Shape should be selected. False any node will do.
Returns:
        list[int]

selectedShapes(self, layer=None, select_all=False, deep=False, extend=None)

Return all shapes that have a node selected.

services(self)

Returns all service layers.

setADVeq(self, equationStr, layer=None)

Set Advance width metric equation on given layer

setAdvance(self, newAdvance, layer=None)

Set the Advance Width (int) at given layer (int or str)

setLSB(self, newLSB, layer=None)

Set the Left Side-bearing (int) at given layer (int or str)

setLSBeq(self, equationStr, layer=None)

Set LSB metric equation on given layer

setMark(self, mark_color, layer=None)

setName(self, glyph_name)

setRSB(self, newRSB, layer=None)

Set the Right Side-bearing (int) at given layer (int or str)

setRSBeq(self, equationStr, layer=None)

Set RSB metric equation on given layer

setTags(self, tagList, append=True)

shapes(self, layer=None, extend=None)

Return all shapes at given layer.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[flShapes]

shapes_data(self, layer=None)

Return all flShapeData objects at given layer.
Args:
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        list[flShapeData]

slant(self, deg, layer=None)

Slant outline at given layer.
Args:
        deg (float): degrees of slant
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        None

tag(self, newTag)

translate(self, dx, dy, layer=None)

Translate (shift) outline at given layer.
Args:
        dx (float), dy (float): delta (shift) X, Y
        layer (int or str): Layer index or name. If None returns ActiveLayer
Returns:
        None

update(self, fl=True, fg=False)

Updates the glyph and sends notification to the editor.
Args:
        fl (bool): Update the flGlyph
        fg (bool): Update the fgGlyph

updateObject(self, flObject, undoMessage='TypeRig', verbose=True)

Updates a flObject sends notification to the editor as well as undo/history item.
Args:
        flObject (flGlyph, flLayer, flShape, flNode, flContour): Object to be update and set undo state
        undoMessage (string): Message to be added in undo/history list.

version(self)

# - Basics -----------------------------------------------

Descriptors from pGlyph

dict

dictionary for instance variables (if defined)

weakref

list of weak references to the object (if defined)

id

index

mark

name

package

tags

unicode

unicodes

class pGlyph(builtin.object)

Proxy to flGlyph and fgGlyph combined into single entity.

Constructor:
        pGlyph() : default represents the current glyph and current font
        pGlyph(flGlyph)
        pGlyph(fgFont, fgGlyph)

Methods:

Attributes:
        .parent (fgFont)
        .fg (fgGlyph)
        .fl (flGlyph)
        ...