from dataclasses import dataclass from fontFeatures import ValueRecord from fontFeatures.utils import categorize_glyph from youseedee import ucd_data import sys import warnings def _add_value_records(vr1, vr2): if vr1.xPlacement or vr2.xPlacement: vr1.xPlacement = (vr1.xPlacement or 0) + (vr2.xPlacement or 0) if vr1.yPlacement or vr2.yPlacement: vr1.yPlacement = (vr1.yPlacement or 0) + (vr2.yPlacement or 0) if vr1.xAdvance or vr2.xAdvance: vr1.xAdvance = (vr1.xAdvance or 0) + (vr2.xAdvance or 0) if vr1.yAdvance or vr2.yAdvance: vr1.yAdvance = (vr1.yAdvance or 0) + (vr2.yAdvance or 0) @dataclass class BufferItem: # codepoint: int # glyph: str # position: ValueRecord # category: str def __repr__(self): s = "" if self.glyph: s = self.glyph if self.category[0] == "base": s = s + "_" elif self.category[0] == "mark": s = s + "^" elif self.category[0] == "ligature": s = s + "(fi)" else: s = s + "?" else: s = "U+%04x" % self.codepoint return "BufferItem(%s)" % s @classmethod def new_unicode(klass, codepoint): self = klass() self.codepoint = codepoint self.glyph = None self.feature_masks = {} return self @classmethod def new_glyph(klass, glyph, font): self = klass() self.codepoint = None self.glyph = glyph self.feature_masks = {} self.prep_glyph(font) return self def map_to_glyph(self, font): if not self.glyph: self.glyph = font.unicode_map.get(self.codepoint) if not self.glyph: # Notdef self.glyph = list(font.glyphs.keys())[0] self.prep_glyph(font) def prep_glyph(self, font): if "pytest" in sys.modules: if self.glyph in font.exported_glyphs(): self.gid = font.exported_glyphs().index(self.glyph) else: self.gid = -1 # ? self.substituted = False self.ligated = False self.multiplied = False self.recategorize(font) try: self.position = ValueRecord(xAdvance=0) self.position.xAdvance = font.default_master.get_glyph_layer( self.glyph ).width except Exception: if "pytest" in sys.modules: # We tolerate broken fonts in pytest pass else: raise ValueError( "Could not get xAdvance for glyph %s (%i)" % (self.glyph, self.codepoint) ) def recategorize(self, font): try: self.category = categorize_glyph(font, self.glyph) if not self.category[0]: self.category = ("unknown", None) except Exception as e: warnings.warn("Error getting category: %s" % str(e)) self._fallback_categorize() def _fallback_categorize(self): if not self.codepoint: # Now what? self.category = ("unknown", None) return genCat = ucd_data(self.codepoint).get("General_Category", "L") if genCat[0] == "M": self.category = ("mark", None) elif genCat == "Ll": self.category = ("ligature", None) elif genCat[0] == "L": self.category = ("base", None) else: self.category = ("unknown", None) def add_position(self, vr2): _add_value_records(self.position, vr2) class Buffer: """A buffer holding either characters to be shaped or shaped glyphs.""" itemclass = BufferItem def __init__( self, font, glyphs=[], unicodes=[], direction=None, script=None, language=None ): self.font = font self.direction = direction self.script = script self.language = language self.fallback_mark_positioning = False self.fallback_glyph_classes = False self.items = [] self.mask = [] self.flags = 0 self.current_feature_mask = None if glyphs: self.store_glyphs(glyphs) self.clear_mask() elif unicodes: self.store_unicode(unicodes) self.guess_segment_properties() def store_glyphs(self, glyphs): """Initialize the buffer with list of glyphs. Args: glyphs (list): A list of glyph names. """ self.items = [self.itemclass.new_glyph(g, self.font) for g in glyphs] def store_unicode(self, unistring): """Initialize the buffer with list of Unicode codepoints. Args: glyphs (list or str): A list of characters. """ self.items = [self.itemclass.new_unicode(ord(char)) for char in unistring] def guess_segment_properties(self): """Try to automatically determine the script and direction properties.""" for u in self.items: # Guess segment properties if not self.script: thisScript = ucd_data(u.codepoint)["Script"] if thisScript not in ["Common", "Unknown", "Inherited"]: self.script = thisScript if not self.direction: from fontFeatures.shaperLib.Shaper import _script_direction self.direction = _script_direction(self.script) def map_to_glyphs(self): """Convert a buffer of codepoints to its initial glyph mapping.""" for u in self.items: u.map_to_glyph(self.font) self.clear_mask() @property def is_all_glyphs(self): """Returns true if the contents are glyph items.""" return all([x.glyph is not None for x in self.items]) @property def is_all_unicodes(self): """Returns true if the contents are character items.""" return all([x.codepoint is not None for x in self.items]) def __getitem__(self, key): indexed = self.mask[key] if isinstance(indexed, range) or isinstance(indexed, slice): indexed = slice(indexed.start, indexed.stop, indexed.step) if isinstance(indexed, list): return [self.items[g] for g in indexed] return self.items[indexed] def __setitem__(self, key, value): indexed = self.mask[key] if len(indexed) == 1: # Easy self.items[indexed[0] : indexed[0] + 1] = value return if len(value) == 1: # Also easy self.items[indexed[0]] = value[0] for i in reversed(indexed[1:]): del self.items[i] return else: raise ValueError("Too hard :-(") def __len__(self): return len(self.mask) def update(self): """Categorises glyphs and recomputes masks. Called internally when the contents of the buffer changes.""" for g in self.items: g.recategorize(self.font) self.recompute_mask() def clear_mask(self): """Clear the buffer mask.""" self.flags = 0 self.markFilteringSet = None self.markAttachmentSet = None self.current_feature_mask = None self.recompute_mask() def set_mask(self, flags, markFilteringSet=None, markAttachmentSet=None): """Apply a routine's flags and mark filtering set to the buffer.""" self.flags = flags if self.flags & 0x10: assert markFilteringSet self.markFilteringSet = markFilteringSet if self.flags & 0xFF00: assert markAttachmentSet self.markAttachmentSet = markAttachmentSet self.recompute_mask() def recompute_mask(self): """Computes the mask property ``buffer.mask`` is a list of buffer item indices which is the current "view" of the buffer. For example, if ``buffer.flags == 0x8``, then the indices of all mark glyphs will be excluded from ``buffer.mask``. """ mask = range(0, len(self.items)) self.flags = self.flags or 0 if self.flags & 0x2: # IgnoreBases mask = list(filter(lambda ix: self.items[ix].category[0] != "base", mask)) if self.flags & 0x4: # IgnoreLigatures mask = list( filter(lambda ix: self.items[ix].category[0] != "ligature", mask) ) if self.flags & 0x8: # IgnoreMarks mask = list(filter(lambda ix: self.items[ix].category[0] != "mark", mask)) if self.flags & 0x10: # UseMarkFilteringSet mask = list( filter( lambda ix: self.items[ix].category[0] != "mark" or self.items[ix].glyph in self.markFilteringSet, mask, ) ) if self.flags & 0xFF00: # MarkAttachmentType mask = list( filter( lambda ix: self.items[ix].category[0] != "mark" or self.items[ix].glyph in self.markAttachmentSet, mask, ) ) if self.current_feature_mask: feature = self.current_feature_mask mask = list( filter( lambda ix: (feature not in self.items[ix].feature_masks) or (not self.items[ix].feature_masks[feature]), mask, ) ) self.mask = mask def set_feature_mask(self, feature): """Applies the mask for a particular feature.""" self.current_feature_mask = feature self.recompute_mask() def move_item(self, src, dest): """Moves an item from src to dest.""" self.items[dest:dest] = [self.items.pop(src)] def merge_clusters(self, start, end): """Currently unimplemented.""" pass # XXX def serialize(self, additional=None, position=True, names=True, ned=False): """Serialize a buffer to a string. Returns: The contents of the given buffer in a string format similar to that used by ``hb-shape``. """ outs = [] if additional: if not isinstance(additional, list): additional = [additional] else: additional = [] xcursor = 0 for ix, info in enumerate(self.items): if hasattr(info, "glyph") and info.glyph: if names: outs.append("%s" % info.glyph) else: outs.append("%s" % info.gid) else: outs.append("U+%04x" % info.codepoint) if ned: position = info.position if xcursor + (position.xPlacement or 0): outs[-1] = outs[-1] + "@%i,%i" % ( xcursor + (position.xPlacement or 0), position.yPlacement or 0, ) xcursor = xcursor + position.xAdvance elif position and hasattr(info, "position"): position = info.position if hasattr(info, "syllable_index"): cluster = info.syllable_index else: cluster = ix outs[-1] = outs[-1] + "=%i" % (cluster) if position.xPlacement or position.yPlacement: outs[-1] = outs[-1] + "@%i,%i" % ( position.xPlacement or 0, position.yPlacement or 0, ) outs[-1] = outs[-1] + "+%i" % (position.xAdvance) relevant = list(filter(lambda a: hasattr(info, a), additional)) if relevant: outs[-1] = outs[-1] + "(%s)" % ",".join( [str(getattr(info, a)) for a in relevant] ) return "|".join(outs)