diff options
Diffstat (limited to 'misc/pylib/robofab/objects')
| -rwxr-xr-x | misc/pylib/robofab/objects/__init__.py | 15 | ||||
| -rwxr-xr-x | misc/pylib/robofab/objects/objectsBase.pyx | 3426 | ||||
| -rw-r--r-- | misc/pylib/robofab/objects/objectsFF.py | 1253 | ||||
| -rwxr-xr-x | misc/pylib/robofab/objects/objectsFL.py | 3112 | ||||
| -rwxr-xr-x | misc/pylib/robofab/objects/objectsRF.pyx | 1233 |
5 files changed, 9039 insertions, 0 deletions
diff --git a/misc/pylib/robofab/objects/__init__.py b/misc/pylib/robofab/objects/__init__.py new file mode 100755 index 000000000..ad85fd002 --- /dev/null +++ b/misc/pylib/robofab/objects/__init__.py @@ -0,0 +1,15 @@ +""" + +Directory for modules supporting + + Unified + + Font + + Objects + +""" + + + + diff --git a/misc/pylib/robofab/objects/objectsBase.pyx b/misc/pylib/robofab/objects/objectsBase.pyx new file mode 100755 index 000000000..3154fb3f4 --- /dev/null +++ b/misc/pylib/robofab/objects/objectsBase.pyx @@ -0,0 +1,3426 @@ +""" +Base classes for the Unified Font Objects (UFO), +a series of classes that deal with fonts, glyphs, +contours and related things. + +Unified Font Objects are: +- platform independent +- application independent + +About Object Inheritance: +objectsFL and objectsRF objects inherit +methods and attributes from these objects. +In other words, if it is in here, you can +do it with the objectsFL and objectsRF. +""" + + +from __future__ import generators +from __future__ import division + +from warnings import warn +import math +import copy + +from robofab import ufoLib +from robofab import RoboFabError +from robofab.misc.arrayTools import updateBounds, pointInRect, unionRect, sectRect +from fontTools.pens.basePen import AbstractPen +from fontTools.pens.areaPen import AreaPen +from ..exceptions import RoboFabError, RoboFabWarning + +try: + set +except NameError: + from sets import Set as set + +#constants for dealing with segments, points and bPoints +MOVE = 'move' +LINE = 'line' +CORNER = 'corner' +CURVE = 'curve' +QCURVE = 'qcurve' +OFFCURVE = 'offcurve' + +DEGREE = 180 / math.pi + + + +# the key for the postscript hint data stored in the UFO +postScriptHintDataLibKey = "org.robofab.postScriptHintData" + +# from http://svn.typesupply.com/packages/fontMath/mathFunctions.py + +def add(v1, v2): + return v1 + v2 + +def sub(v1, v2): + return v1 - v2 + +def mul(v, f): + return v * f + +def div(v, f): + return v / f + +def issequence(x): + "Is x a sequence? We say it is if it has a __getitem__ method." + return hasattr(x, '__getitem__') + + + +class BasePostScriptHintValues(object): + """ Base class for postscript hinting information. + """ + + def __init__(self, data=None): + if data is not None: + self.fromDict(data) + else: + for name in self._attributeNames.keys(): + setattr(self, name, self._attributeNames[name]['default']) + + def getParent(self): + """this method will be overwritten with a weakref if there is a parent.""" + return None + + def setParent(self, parent): + import weakref + self.getParent = weakref.ref(parent) + + def isEmpty(self): + """Check all attrs and decide if they're all empty.""" + empty = True + for name in self._attributeNames: + if getattr(self, name): + empty = False + break + return empty + + def clear(self): + """Set all attributes to default / empty""" + for name in self._attributeNames: + setattr(self, name, self._attributeNames[name]['default']) + + def _loadFromLib(self, lib): + data = lib.get(postScriptHintDataLibKey) + if data is not None: + self.fromDict(data) + + def _saveToLib(self, lib): + parent = self.getParent() + if parent is not None: + parent.setChanged(True) + hintsDict = self.asDict() + if hintsDict: + lib[postScriptHintDataLibKey] = hintsDict + + def fromDict(self, data): + for name in self._attributeNames: + if name in data: + setattr(self, name, data[name]) + + def asDict(self): + d = {} + for name in self._attributeNames: + try: + value = getattr(self, name) + except AttributeError: + print "%s attribute not supported"%name + continue + if value: + d[name] = getattr(self, name) + return d + + def update(self, other): + assert isinstance(other, BasePostScriptHintValues) + for name in self._attributeNames.keys(): + v = getattr(other, name) + if v is not None: + setattr(self, name, v) + + def __repr__(self): + return "<Base PS Hint Data>" + + def copy(self, aParent=None): + """Duplicate this object. Pass an object for parenting if you want.""" + n = self.__class__(data=self.asDict()) + if aParent is not None: + n.setParent(aParent) + elif self.getParent() is not None: + n.setParent(self.getParent()) + dont = ['getParent'] + for k in self.__dict__.keys(): + if k in dont: + continue + dup = copy.deepcopy(self.__dict__[k]) + setattr(n, k, dup) + return n + +class BasePostScriptGlyphHintValues(BasePostScriptHintValues): + """ Base class for glyph-level postscript hinting information. + vStems, hStems + """ + _attributeNames = { + # some of these values can have only a certain number of elements + 'vHints': {'default': None, 'max':100, 'isVertical':True}, + 'hHints': {'default': None, 'max':100, 'isVertical':False}, + } + + def __init__(self, data=None): + if data is not None: + self.fromDict(data) + else: + for name in self._attributeNames.keys(): + setattr(self, name, self._attributeNames[name]['default']) + + def __repr__(self): + return "<PostScript Glyph Hints Values>" + + def round(self): + """Round the values to reasonable values. + - stems are rounded to int + """ + for name, values in self._attributeNames.items(): + v = getattr(self, name) + if v is None: + continue + new = [] + for n in v: + new.append((int(round(n[0])), int(round(n[1])))) + setattr(self, name, new) + + # math operations for psHint object + # Note: math operations can change integers to floats. + def __add__(self, other): + assert isinstance(other, BasePostScriptHintValues) + copied = self.copy() + self._processMathOne(copied, other, add) + return copied + + def __sub__(self, other): + assert isinstance(other, BasePostScriptHintValues) + copied = self.copy() + self._processMathOne(copied, other, sub) + return copied + + def __mul__(self, factor): + #if isinstance(factor, tuple): + # factor = factor[0] + copiedInfo = self.copy() + self._processMathTwo(copiedInfo, factor, mul) + return copiedInfo + + __rmul__ = __mul__ + + def __div__(self, factor): + #if isinstance(factor, tuple): + # factor = factor[0] + copiedInfo = self.copy() + self._processMathTwo(copiedInfo, factor, div) + return copiedInfo + + __rdiv__ = __div__ + + def _processMathOne(self, copied, other, funct): + for name, values in self._attributeNames.items(): + a = None + b = None + v = None + if hasattr(copied, name): + a = getattr(copied, name) + if hasattr(other, name): + b = getattr(other, name) + if a is not None and b is not None: + if len(a) != len(b): + # can't do math with non matching zones + continue + l = len(a) + for i in range(l): + if v is None: + v = [] + ai = a[i] + bi = b[i] + l2 = min(len(ai), len(bi)) + v2 = [funct(ai[j], bi[j]) for j in range(l2)] + v.append(v2) + if v is not None: + setattr(copied, name, v) + + def _processMathTwo(self, copied, factor, funct): + for name, values in self._attributeNames.items(): + a = None + b = None + v = None + isVertical = self._attributeNames[name]['isVertical'] + splitFactor = factor + if isinstance(factor, tuple): + #print "mathtwo", name, funct, factor, isVertical + if isVertical: + splitFactor = factor[1] + else: + splitFactor = factor[0] + if hasattr(copied, name): + a = getattr(copied, name) + if a is not None: + for i in range(len(a)): + if v is None: + v = [] + v2 = [funct(a[i][j], splitFactor) for j in range(len(a[i]))] + v.append(v2) + if v is not None: + setattr(copied, name, v) + + +class BasePostScriptFontHintValues(BasePostScriptHintValues): + """ Base class for font-level postscript hinting information. + Blues values, stem values. + """ + + _attributeNames = { + # some of these values can have only a certain number of elements + # default: what the value should be when initialised + # max: the maximum number of items this attribute is allowed to have + # isVertical: the vertical relevance + 'blueFuzz': {'default': None, 'max':1, 'isVertical':True}, + 'blueScale': {'default': None, 'max':1, 'isVertical':True}, + 'blueShift': {'default': None, 'max':1, 'isVertical':True}, + 'forceBold': {'default': None, 'max':1, 'isVertical':False}, + 'blueValues': {'default': None, 'max':7, 'isVertical':True}, + 'otherBlues': {'default': None, 'max':5, 'isVertical':True}, + 'familyBlues': {'default': None, 'max':7, 'isVertical':True}, + 'familyOtherBlues': {'default': None, 'max':5, 'isVertical':True}, + 'vStems': {'default': None, 'max':6, 'isVertical':True}, + 'hStems': {'default': None, 'max':11, 'isVertical':False}, + } + + def __init__(self, data=None): + if data is not None: + self.fromDict(data) + + def __repr__(self): + return "<PostScript Font Hints Values>" + + # route attribute calls to info object + + def _bluesToPairs(self, values): + values.sort() + finalValues = [] + for value in values: + if not finalValues or len(finalValues[-1]) == 2: + finalValues.append([]) + finalValues[-1].append(value) + return finalValues + + def _bluesFromPairs(self, values): + finalValues = [] + for value1, value2 in values: + finalValues.append(value1) + finalValues.append(value2) + finalValues.sort() + return finalValues + + def _get_blueValues(self): + values = self.getParent().info.postscriptBlueValues + if values is None: + values = [] + values = self._bluesToPairs(values) + return values + + def _set_blueValues(self, values): + if values is None: + values = [] + values = self._bluesFromPairs(values) + self.getParent().info.postscriptBlueValues = values + + blueValues = property(_get_blueValues, _set_blueValues) + + def _get_otherBlues(self): + values = self.getParent().info.postscriptOtherBlues + if values is None: + values = [] + values = self._bluesToPairs(values) + return values + + def _set_otherBlues(self, values): + if values is None: + values = [] + values = self._bluesFromPairs(values) + self.getParent().info.postscriptOtherBlues = values + + otherBlues = property(_get_otherBlues, _set_otherBlues) + + def _get_familyBlues(self): + values = self.getParent().info.postscriptFamilyBlues + if values is None: + values = [] + values = self._bluesToPairs(values) + return values + + def _set_familyBlues(self, values): + if values is None: + values = [] + values = self._bluesFromPairs(values) + self.getParent().info.postscriptFamilyBlues = values + + familyBlues = property(_get_familyBlues, _set_familyBlues) + + def _get_familyOtherBlues(self): + values = self.getParent().info.postscriptFamilyOtherBlues + if values is None: + values = [] + values = self._bluesToPairs(values) + return values + + def _set_familyOtherBlues(self, values): + if values is None: + values = [] + values = self._bluesFromPairs(values) + self.getParent().info.postscriptFamilyOtherBlues = values + + familyOtherBlues = property(_get_familyOtherBlues, _set_familyOtherBlues) + + def _get_vStems(self): + return self.getParent().info.postscriptStemSnapV + + def _set_vStems(self, value): + if value is None: + value = [] + self.getParent().info.postscriptStemSnapV = list(value) + + vStems = property(_get_vStems, _set_vStems) + + def _get_hStems(self): + return self.getParent().info.postscriptStemSnapH + + def _set_hStems(self, value): + if value is None: + value = [] + self.getParent().info.postscriptStemSnapH = list(value) + + hStems = property(_get_hStems, _set_hStems) + + def _get_blueScale(self): + return self.getParent().info.postscriptBlueScale + + def _set_blueScale(self, value): + self.getParent().info.postscriptBlueScale = value + + blueScale = property(_get_blueScale, _set_blueScale) + + def _get_blueShift(self): + return self.getParent().info.postscriptBlueShift + + def _set_blueShift(self, value): + self.getParent().info.postscriptBlueShift = value + + blueShift = property(_get_blueShift, _set_blueShift) + + def _get_blueFuzz(self): + return self.getParent().info.postscriptBlueFuzz + + def _set_blueFuzz(self, value): + self.getParent().info.postscriptBlueFuzz = value + + blueFuzz = property(_get_blueFuzz, _set_blueFuzz) + + def _get_forceBold(self): + return self.getParent().info.postscriptForceBold + + def _set_forceBold(self, value): + self.getParent().info.postscriptForceBold = value + + forceBold = property(_get_forceBold, _set_forceBold) + + def round(self): + """Round the values to reasonable values. + - blueScale is not rounded, it is a float + - forceBold is set to False if -0.5 < value < 0.5. Otherwise it will be True. + - blueShift, blueFuzz are rounded to int + - stems are rounded to int + - blues are rounded to int + """ + for name, values in self._attributeNames.items(): + if name == "blueScale": + continue + elif name == "forceBold": + v = getattr(self, name) + if v is None: + continue + if -0.5 <= v <= 0.5: + setattr(self, name, False) + else: + setattr(self, name, True) + elif name in ['blueFuzz', 'blueShift']: + v = getattr(self, name) + if v is None: + continue + setattr(self, name, int(round(v))) + elif name in ['hStems', 'vStems']: + v = getattr(self, name) + if v is None: + continue + new = [] + for n in v: + new.append(int(round(n))) + setattr(self, name, new) + else: + v = getattr(self, name) + if v is None: + continue + new = [] + for n in v: + new.append([int(round(m)) for m in n]) + setattr(self, name, new) + + + +class RoboFabInterpolationError(Exception): pass + + +def _interpolate(a,b,v): + """interpolate values by factor v""" + return a + (b-a) * v + +def _interpolatePt(a, b, v): + """interpolate point by factor v""" + xa, ya = a + xb, yb = b + if not isinstance(v, tuple): + xv = v + yv = v + else: + xv, yv = v + return xa + (xb-xa) * xv, ya + (yb-ya) * yv + +def _scalePointFromCenter(pt, scale, center): + """scale a point from a center point""" + pointX, pointY = pt + scaleX, scaleY = scale + centerX, centerY = center + ogCenter = center + scaledCenter = (centerX * scaleX, centerY * scaleY) + shiftVal = (scaledCenter[0] - ogCenter[0], scaledCenter[1] - ogCenter[1]) + scaledPointX = (pointX * scaleX) - shiftVal[0] + scaledPointY = (pointY * scaleY) - shiftVal[1] + return (scaledPointX, scaledPointY) + +def _box(objectToMeasure, fontObject=None): + """calculate the bounds of the object and return it as a (xMin, yMin, xMax, yMax)""" + #from fontTools.pens.boundsPen import BoundsPen + from robofab.pens.boundsPen import BoundsPen + boundsPen = BoundsPen(glyphSet=fontObject) + objectToMeasure.draw(boundsPen) + bounds = boundsPen.bounds + if bounds is None: + bounds = (0, 0, 0, 0) + return bounds + +def roundPt(pt): + """Round a vector""" + return int(round(pt[0])), int(round(pt[1])) + +def addPt(ptA, ptB): + """Add two vectors""" + return ptA[0] + ptB[0], ptA[1] + ptB[1] + +def subPt(ptA, ptB): + """Substract two vectors""" + return ptA[0] - ptB[0], ptA[1] - ptB[1] + +def mulPt(ptA, scalar): + """Multiply a vector with scalar""" + if not isinstance(scalar, tuple): + f1 = scalar + f2 = scalar + else: + f1, f2 = scalar + return ptA[0]*f1, ptA[1]*f2 + +def relativeBCPIn(anchor, BCPIn): + """convert absolute incoming bcp value to a relative value""" + return (BCPIn[0] - anchor[0], BCPIn[1] - anchor[1]) + +def absoluteBCPIn(anchor, BCPIn): + """convert relative incoming bcp value to an absolute value""" + return (BCPIn[0] + anchor[0], BCPIn[1] + anchor[1]) + +def relativeBCPOut(anchor, BCPOut): + """convert absolute outgoing bcp value to a relative value""" + return (BCPOut[0] - anchor[0], BCPOut[1] - anchor[1]) + +def absoluteBCPOut(anchor, BCPOut): + """convert relative outgoing bcp value to an absolute value""" + return (BCPOut[0] + anchor[0], BCPOut[1] + anchor[1]) + +class FuzzyNumber(object): + + def __init__(self, value, threshold): + self.value = value + self.threshold = threshold + + def __cmp__(self, other): + if abs(self.value - other.value) < self.threshold: + return 0 + else: + return cmp(self.value, other.value) + + +class RBaseObject(object): + + """Base class for wrapper objects""" + + attrMap= {} + _title = "RoboFab Wrapper" + + def __init__(self): + self._object = {} + self.changed = False # if the object needs to be saved + self.selected = False + + def __len__(self): + return len(self._object) + + def __repr__(self): + try: + name = `self._object` + except: + name = "None" + return "<%s for %s>" %(self._title, name) + + def copy(self, aParent=None): + """Duplicate this object. Pass an object for parenting if you want.""" + n = self.__class__() + if aParent is not None: + n.setParent(aParent) + elif self.getParent() is not None: + n.setParent(self.getParent()) + dont = ['getParent'] + for k in self.__dict__.keys(): + if k in dont: + continue + elif isinstance(self.__dict__[k], (RBaseObject, BaseLib)): + dup = self.__dict__[k].copy(n) + else: + dup = copy.deepcopy(self.__dict__[k]) + setattr(n, k, dup) + return n + + def round(self): + pass + + def isRobofab(self): + """Presence of this method indicates a Robofab object""" + return 1 + + def naked(self): + """Return the wrapped object itself, in case it is needed for direct access.""" + return self._object + + def setChanged(self, state=True): + self.changed = state + + def getParent(self): + """this method will be overwritten with a weakref if there is a parent.""" + return None + + def setParent(self, parent): + import weakref + self.getParent = weakref.ref(parent) + + def _writeXML(self, writer): + pass + + def dump(self, private=False): + """Print a dump of this object to the std out.""" + from robofab.tools.objectDumper import dumpObject + dumpObject(self, private) + + + +class BaseFont(RBaseObject): + + """Base class for all font objects.""" + + _allFonts = [] + + def __init__(self): + import weakref + RBaseObject.__init__(self) + self.changed = False # if the object needs to be saved + self._allFonts.append(weakref.ref(self)) + self._supportHints = False + + def __repr__(self): + try: + name = self.info.postscriptFullName + except AttributeError: + name = "unnamed_font" + return "<RFont font for %s>" %(name) + + def __eq__(self, other): + #Compare this font with another, compare if they refer to the same file. + return self._compare(other) + + def _compare(self, other): + """Compare this font to other. RF and FL UFO implementations need + slightly different ways of comparing fonts. This method does the + basic stuff. Start with simple and quick comparisons, then move into + detailed comparisons of glyphs.""" + if not hasattr(other, "fileName"): + return False + if self.fileName is not None and self.fileName == other.fileName: + return True + if self.fileName <> other.fileName: + return False + # this will falsely identify two distinct "Untitled" as equal + # so test some more. A lot of work to please some dolt who + # does not save his fonts while running scripts. + try: + if len(self) <> len(other): + return False + except TypeError: + return False + # same name and length. start comparing glyphs + namesSelf = self.keys() + namesOther = other.keys() + namesSelf.sort() + namesOther.sort() + for i in range(len(namesSelf)): + if namesSelf[i] <> namesOther[i]: + return False + for c in self: + if not c == other[c.name]: + return False + return True + + def keys(self): + # must be implemented by subclass + raise NotImplementedError + + def __iter__(self): + for glyphName in self.keys(): + yield self.getGlyph(glyphName) + + def __getitem__(self, glyphName): + return self.getGlyph(glyphName) + + def __contains__(self, glyphName): + return self.has_key(glyphName) + + def _hasChanged(self): + #mark the object as changed + self.setChanged(True) + + def update(self): + """update the font""" + pass + + def close(self, save=1): + """Close the font, saving is optional.""" + pass + + def round(self): + """round all of the points in all of the glyphs""" + for glyph in self: + glyph.round() + + def autoUnicodes(self): + """Using fontTools.agl, assign Unicode lists to all glyphs in the font""" + for glyph in self: + glyph.autoUnicodes() + + def getCharacterMapping(self): + """Create a dictionary of unicode -> [glyphname, ...] mappings. + Note that this dict is created each time this method is called, + which can make it expensive for larger fonts. All glyphs are loaded. + Note that one glyph can have multiple unicode values, + and a unicode value can have multiple glyphs pointing to it.""" + map = {} + for glyph in self: + for u in glyph.unicodes: + if not map.has_key(u): + map[u] = [] + map[u].append(glyph.name) + return map + + def getReverseComponentMapping(self): + """ + Get a reversed map of component references in the font. + { + 'A' : ['Aacute', 'Aring'] + 'acute' : ['Aacute'] + 'ring' : ['Aring'] + etc. + } + """ + map = {} + for glyph in self: + glyphName = glyph.name + for component in glyph.components: + baseGlyphName = component.baseGlyph + if not map.has_key(baseGlyphName): + map[baseGlyphName] = [] + map[baseGlyphName].append(glyphName) + return map + + def compileGlyph(self, glyphName, baseName, accentNames, \ + adjustWidth=False, preflight=False, printErrors=True): + """Compile components into a new glyph using components and anchorpoints. + glyphName: the name of the glyph where it all needs to go + baseName: the name of the base glyph + accentNames: a list of accentName, anchorName tuples, [('acute', 'top'), etc] + """ + anchors = {} + errors = {} + baseGlyph = self[baseName] + for anchor in baseGlyph.getAnchors(): + anchors[anchor.name] = anchor.position + destGlyph = self.newGlyph(glyphName, clear=True) + destGlyph.appendComponent(baseName) + destGlyph.width = baseGlyph.width + for accentName, anchorName in accentNames: + try: + accent = self[accentName] + except IndexError: + errors["glyph '%s' is missing in font %s"%(accentName, self.info.fullName)] = 1 + continue + shift = None + for accentAnchor in accent.getAnchors(): + if '_'+anchorName == accentAnchor.name: + shift = anchors[anchorName][0] - accentAnchor.position[0], anchors[anchorName][1] - accentAnchor.position[1] + destGlyph.appendComponent(accentName, offset=shift) + break + if shift is not None: + for accentAnchor in accent.getAnchors(): + if accentAnchor.name in anchors: + anchors[accentAnchor.name] = shift[0]+accentAnchor.position[0], shift[1]+accentAnchor.position[1] + if printErrors: + for px in errors.keys(): + print px + return destGlyph + + def generateGlyph(self, glyphName, replace=1, preflight=False, printErrors=True): + """Generate a glyph and return it. Assembled from GlyphConstruction.txt""" + from robofab.tools.toolsAll import readGlyphConstructions + con = readGlyphConstructions() + entry = con.get(glyphName, None) + if not entry: + print "glyph '%s' is not listed in the robofab/Data/GlyphConstruction.txt"%(glyphName) + return + baseName = con[glyphName][0] + parts = con[glyphName][1:] + return self.compileGlyph(glyphName, baseName, parts, adjustWidth=1, preflight=preflight, printErrors=printErrors) + + def interpolate(self, factor, minFont, maxFont, suppressError=True, analyzeOnly=False, doProgress=False): + """Traditional interpolation method. Interpolates by factor between minFont and maxFont. + suppressError will supress all tracebacks and analyze only will not perform the interpolation + but it will analyze all glyphs and return a dict of problems.""" + errors = {} + if not isinstance(factor, tuple): + factor = factor, factor + minGlyphNames = minFont.keys() + maxGlyphNames = maxFont.keys() + allGlyphNames = list(set(minGlyphNames) | set(maxGlyphNames)) + if doProgress: + from robofab.interface.all.dialogs import ProgressBar + progress = ProgressBar('Interpolating...', len(allGlyphNames)) + tickCount = 0 + # some dimensions and values + self.info.ascender = _interpolate(minFont.info.ascender, maxFont.info.ascender, factor[1]) + self.info.descender = _interpolate(minFont.info.descender, maxFont.info.descender, factor[1]) + # check for the presence of the glyph in each of the fonts + for glyphName in allGlyphNames: + if doProgress: + progress.label(glyphName) + fatalError = False + if glyphName not in minGlyphNames: + fatalError = True + if not errors.has_key('Missing Glyphs'): + errors['Missing Glyphs'] = [] + errors['Missing Glyphs'].append('Interpolation Error: %s not in %s'%(glyphName, minFont.info.postscriptFullName)) + if glyphName not in maxGlyphNames: + fatalError = True + if not errors.has_key('Missing Glyphs'): + errors['Missing Glyphs'] = [] + errors['Missing Glyphs'].append('Interpolation Error: %s not in %s'%(glyphName, maxFont.info.postscriptFullName)) + # if no major problems, proceed. + if not fatalError: + # remove the glyph since FontLab has a problem with + # interpolating an existing glyph that contains + # some contour data. + oldLib = {} + oldMark = None + oldNote = None + if self.has_key(glyphName): + glyph = self[glyphName] + oldLib = dict(glyph.lib) + oldMark = glyph.mark + oldNote = glyph.note + self.removeGlyph(glyphName) + selfGlyph = self.newGlyph(glyphName) + selfGlyph.lib.update(oldLib) + if oldMark != None: + selfGlyph.mark = oldMark + selfGlyph.note = oldNote + min = minFont[glyphName] + max = maxFont[glyphName] + ok, glyphErrors = selfGlyph.interpolate(factor, min, max, suppressError=suppressError, analyzeOnly=analyzeOnly) + if not errors.has_key('Glyph Errors'): + errors['Glyph Errors'] = {} + errors['Glyph Errors'][glyphName] = glyphErrors + if doProgress: + progress.tick(tickCount) + tickCount = tickCount + 1 + if doProgress: + progress.close() + return errors + + def getGlyphNameToFileNameFunc(self): + funcName = self.lib.get("org.robofab.glyphNameToFileNameFuncName") + if funcName is None: + return None + parts = funcName.split(".") + module = ".".join(parts[:-1]) + try: + item = __import__(module) + for sub in parts[1:]: + item = getattr(item, sub) + except (ImportError, AttributeError): + warn("Can't find glyph name to file name converter function, " + "falling back to default scheme (%s)" % funcName, RoboFabWarning) + return None + else: + return item + + +class BaseGlyph(RBaseObject): + + """Base class for all glyph objects.""" + + def __init__(self): + RBaseObject.__init__(self) + #self.contours = [] + #self.components = [] + #self.anchors = [] + #self.width = 0 + #self.note = None + ##self.unicodes = [] + #self.selected = None + self.changed = False # if the object needs to be saved + + def __repr__(self): + font = "unnamed_font" + glyph = "unnamed_glyph" + fontParent = self.getParent() + if fontParent is not None: + try: + font = fontParent.info.postscriptFullName + except AttributeError: + pass + try: + glyph = self.name + except AttributeError: + pass + return "<RGlyph for %s.%s>" %(font, glyph) + + # + # Glyph Math + # + + def _getMathData(self): + from robofab.pens.mathPens import GetMathDataPointPen + pen = GetMathDataPointPen() + self.drawPoints(pen) + data = pen.getData() + return data + + def _setMathData(self, data, destination=None): + from robofab.pens.mathPens import CurveSegmentFilterPointPen + if destination is None: + newGlyph = self._mathCopy() + else: + newGlyph = destination + newGlyph.clear() + # + # draw the data onto the glyph + pointPen = newGlyph.getPointPen() + filterPen = CurveSegmentFilterPointPen(pointPen) + for contour in data['contours']: + filterPen.beginPath() + for segmentType, pt, smooth, name in contour: + filterPen.addPoint(pt=pt, segmentType=segmentType, smooth=smooth, name=name) + filterPen.endPath() + for baseName, transformation in data['components']: + filterPen.addComponent(baseName, transformation) + for pt, name in data['anchors']: + filterPen.beginPath() + filterPen.addPoint(pt=pt, segmentType="move", smooth=False, name=name) + filterPen.endPath() + newGlyph.width = data['width'] + psHints = data.get('psHints') + if psHints is not None: + newGlyph.psHints.update(psHints) + # + return newGlyph + + def _getMathDestination(self): + # make a new, empty glyph + return self.__class__() + + def _mathCopy(self): + # copy self without contour, component and anchor data + glyph = self._getMathDestination() + glyph.name = self.name + glyph.unicodes = list(self.unicodes) + glyph.width = self.width + glyph.note = self.note + glyph.lib = dict(self.lib) + return glyph + + def _processMathOne(self, otherGlyph, funct): + # used by: __add__, __sub__ + # + newData = { + 'contours':[], + 'components':[], + 'anchors':[], + 'width':None + } + selfData = self._getMathData() + otherData = otherGlyph._getMathData() + # + # contours + selfContours = selfData['contours'] + otherContours = otherData['contours'] + newContours = newData['contours'] + if len(selfContours) > 0: + for contourIndex in xrange(len(selfContours)): + newContours.append([]) + selfContour = selfContours[contourIndex] + otherContour = otherContours[contourIndex] + for pointIndex in xrange(len(selfContour)): + segType, pt, smooth, name = selfContour[pointIndex] + newX, newY = funct(selfContour[pointIndex][1], otherContour[pointIndex][1]) + newContours[-1].append((segType, (newX, newY), smooth, name)) + # anchors + selfAnchors = selfData['anchors'] + otherAnchors = otherData['anchors'] + newAnchors = newData['anchors'] + if len(selfAnchors) > 0: + selfAnchors, otherAnchors = self._mathAnchorCompare(selfAnchors, otherAnchors) + anchorNames = selfAnchors.keys() + for anchorName in anchorNames: + selfAnchorList = selfAnchors[anchorName] + otherAnchorList = otherAnchors[anchorName] + for i in range(len(selfAnchorList)): + selfAnchor = selfAnchorList[i] + otherAnchor = otherAnchorList[i] + newAnchor = funct(selfAnchor, otherAnchor) + newAnchors.append((newAnchor, anchorName)) + # components + selfComponents = selfData['components'] + otherComponents = otherData['components'] + newComponents = newData['components'] + if len(selfComponents) > 0: + selfComponents, otherComponents = self._mathComponentCompare(selfComponents, otherComponents) + componentNames = selfComponents.keys() + for componentName in componentNames: + selfComponentList = selfComponents[componentName] + otherComponentList = otherComponents[componentName] + for i in range(len(selfComponentList)): + # transformation breakdown: xScale, xyScale, yxScale, yScale, xOffset, yOffset + selfXScale, selfXYScale, selfYXScale, selfYScale, selfXOffset, selfYOffset = selfComponentList[i] + otherXScale, otherXYScale, otherYXScale, otherYScale, otherXOffset, otherYOffset = otherComponentList[i] + newXScale, newXYScale = funct((selfXScale, selfXYScale), (otherXScale, otherXYScale)) + newYXScale, newYScale = funct((selfYXScale, selfYScale), (otherYXScale, otherYScale)) + newXOffset, newYOffset = funct((selfXOffset, selfYOffset), (otherXOffset, otherYOffset)) + newComponents.append((componentName, (newXScale, newXYScale, newYXScale, newYScale, newXOffset, newYOffset))) + return newData + + def _processMathTwo(self, factor, funct): + # used by: __mul__, __div__ + # + newData = { + 'contours':[], + 'components':[], + 'anchors':[], + 'width':None + } + selfData = self._getMathData() + # contours + selfContours = selfData['contours'] + newContours = newData['contours'] + for selfContour in selfContours: + newContours.append([]) + for segType, pt, smooth, name in selfContour: + newX, newY = funct(pt, factor) + newContours[-1].append((segType, (newX, newY), smooth, name)) + # anchors + selfAnchors = selfData['anchors'] + newAnchors = newData['anchors'] + for pt, anchorName in selfAnchors: + newPt = funct(pt, factor) + newAnchors.append((newPt, anchorName)) + # components + selfComponents = selfData['components'] + newComponents = newData['components'] + for baseName, transformation in selfComponents: + xScale, xyScale, yxScale, yScale, xOffset, yOffset = transformation + newXOffset, newYOffset = funct((xOffset, yOffset), factor) + newXScale, newYScale = funct((xScale, yScale), factor) + newXYScale, newYXScale = funct((xyScale, yxScale), factor) + newComponents.append((baseName, (newXScale, newXYScale, newYXScale, newYScale, newXOffset, newYOffset))) + # return the data + return newData + + def _mathAnchorCompare(self, selfMathAnchors, otherMathAnchors): + # collect compatible anchors + selfAnchors = {} + for pt, name in selfMathAnchors: + if not selfAnchors.has_key(name): + selfAnchors[name] = [] + selfAnchors[name].append(pt) + otherAnchors = {} + for pt, name in otherMathAnchors: + if not otherAnchors.has_key(name): + otherAnchors[name] = [] + otherAnchors[name].append(pt) + compatAnchors = set(selfAnchors.keys()) & set(otherAnchors.keys()) + finalSelfAnchors = {} + finalOtherAnchors = {} + for name in compatAnchors: + if not finalSelfAnchors.has_key(name): + finalSelfAnchors[name] = [] + if not finalOtherAnchors.has_key(name): + finalOtherAnchors[name] = [] + selfList = selfAnchors[name] + otherList = otherAnchors[name] + selfCount = len(selfList) + otherCount = len(otherList) + if selfCount != otherCount: + r = range(min(selfCount, otherCount)) + else: + r = range(selfCount) + for i in r: + finalSelfAnchors[name].append(selfList[i]) + finalOtherAnchors[name].append(otherList[i]) + return finalSelfAnchors, finalOtherAnchors + + def _mathComponentCompare(self, selfMathComponents, otherMathComponents): + # collect compatible components + selfComponents = {} + for baseName, transformation in selfMathComponents: + if not selfComponents.has_key(baseName): + selfComponents[baseName] = [] + selfComponents[baseName].append(transformation) + otherComponents = {} + for baseName, transformation in otherMathComponents: + if not otherComponents.has_key(baseName): + otherComponents[baseName] = [] + otherComponents[baseName].append(transformation) + compatComponents = set(selfComponents.keys()) & set(otherComponents.keys()) + finalSelfComponents = {} + finalOtherComponents = {} + for baseName in compatComponents: + if not finalSelfComponents.has_key(baseName): + finalSelfComponents[baseName] = [] + if not finalOtherComponents.has_key(baseName): + finalOtherComponents[baseName] = [] + selfList = selfComponents[baseName] + otherList = otherComponents[baseName] + selfCount = len(selfList) + otherCount = len(otherList) + if selfCount != otherCount: + r = range(min(selfCount, otherCount)) + else: + r = range(selfCount) + for i in r: + finalSelfComponents[baseName].append(selfList[i]) + finalOtherComponents[baseName].append(otherList[i]) + return finalSelfComponents, finalOtherComponents + + def __mul__(self, factor): + assert isinstance(factor, (int, float, tuple)), "Glyphs can only be multiplied by int, float or a 2-tuple." + if not isinstance(factor, tuple): + factor = (factor, factor) + data = self._processMathTwo(factor, mulPt) + data['width'] = self.width * factor[0] + # psHints + if not self.psHints.isEmpty(): + newPsHints = self.psHints * factor + data['psHints'] = newPsHints + return self._setMathData(data) + + __rmul__ = __mul__ + + def __div__(self, factor): + assert isinstance(factor, (int, float, tuple)), "Glyphs can only be divided by int, float or a 2-tuple." + # calculate reverse factor, and cause nice ZeroDivisionError if it can't + if isinstance(factor, tuple): + reverse = 1.0/factor[0], 1.0/factor[1] + else: + reverse = 1.0/factor + return self.__mul__(reverse) + + def __add__(self, other): + assert isinstance(other, BaseGlyph), "Glyphs can only be added to other glyphs." + data = self._processMathOne(other, addPt) + data['width'] = self.width + other.width + return self._setMathData(data) + + def __sub__(self, other): + assert isinstance(other, BaseGlyph), "Glyphs can only be substracted from other glyphs." + data = self._processMathOne(other, subPt) + data['width'] = self.width + other.width + return self._setMathData(data) + + # + # Interpolation + # + + def interpolate(self, factor, minGlyph, maxGlyph, suppressError=True, analyzeOnly=False): + """Traditional interpolation method. Interpolates by factor between minGlyph and maxGlyph. + suppressError will supress all tracebacks and analyze only will not perform the interpolation + but it will analyze all glyphs and return a dict of problems.""" + if not isinstance(factor, tuple): + factor = factor, factor + fatalError = False + if analyzeOnly: + ok, errors = minGlyph.isCompatible(maxGlyph) + return ok, errors + minData = None + maxData = None + minName = minGlyph.name + maxName = maxGlyph.name + try: + minData = minGlyph._getMathData() + maxData = maxGlyph._getMathData() + newContours = self._interpolateContours(factor, minData['contours'], maxData['contours']) + newComponents = self._interpolateComponents(factor, minData['components'], maxData['components']) + newAnchors = self._interpolateAnchors(factor, minData['anchors'], maxData['anchors']) + newWidth = _interpolate(minGlyph.width, maxGlyph.width, factor[0]) + newData = { + 'contours':newContours, + 'components':newComponents, + 'anchors':newAnchors, + 'width':newWidth + } + self._setMathData(newData, self) + except IndexError: + if not suppressError: + ok, errors = minGlyph.isCompatible(maxGlyph) + ok = not ok + return ok, errors + self.update() + return False, [] + + def isCompatible(self, otherGlyph, report=True): + """Return a bool value if the glyph is compatible with otherGlyph. + With report = True, isCompatible will return a report of what's wrong. + The interpolate method requires absolute equality between contour data. + Absolute equality is preferred among component and anchor data, but + it is NOT required. Interpolation between components and anchors + will only deal with compatible data and incompatible data will be + ignored. This method reflects this system.""" + selfName = self.name + selfData = self._getMathData() + otherName = otherGlyph.name + otherData = otherGlyph._getMathData() + compatible, errors = self._isCompatibleInternal(selfName, otherName, selfData, otherData) + if report: + return compatible, errors + return compatible + + def _isCompatibleInternal(self, selfName, otherName, selfData, otherData): + fatalError = False + errors = [] + ## contours + # any contour incompatibilities + # result in fatal errors + selfContours = selfData['contours'] + otherContours = otherData['contours'] + if len(selfContours) != len(otherContours): + fatalError = True + errors.append("Fatal error: glyph %s and glyph %s don't have the same number of contours." %(selfName, otherName)) + else: + for contourIndex in xrange(len(selfContours)): + selfContour = selfContours[contourIndex] + otherContour = otherContours[contourIndex] + if len(selfContour) != len(otherContour): + fatalError = True + errors.append("Fatal error: contour %d in glyph %s and glyph %s don't have the same number of segments." %(contourIndex, selfName, otherName)) + ## components + # component incompatibilities + # do not result in fatal errors + selfComponents = selfData['components'] + otherComponents = otherData['components'] + if len(selfComponents) != len(otherComponents): + errors.append("Error: glyph %s and glyph %s don't have the same number of components." %(selfName, otherName)) + for componentIndex in xrange(min(len(selfComponents), len(otherComponents))): + selfBaseName, selfTransformation = selfComponents[componentIndex] + otherBaseName, otherTransformation = otherComponents[componentIndex] + if selfBaseName != otherBaseName: + errors.append("Error: component %d in glyph %s and glyph %s don't have the same base glyph." %(componentIndex, selfName, otherName)) + ## anchors + # anchor incompatibilities + # do not result in fatal errors + selfAnchors = selfData['anchors'] + otherAnchors = otherData['anchors'] + if len(selfAnchors) != len(otherAnchors): + errors.append("Error: glyph %s and glyph %s don't have the same number of anchors." %(selfName, otherName)) + for anchorIndex in xrange(min(len(selfAnchors), len(otherAnchors))): + selfPt, selfAnchorName = selfAnchors[anchorIndex] + otherPt, otherAnchorName = otherAnchors[anchorIndex] + if selfAnchorName != otherAnchorName: + errors.append("Error: anchor %d in glyph %s and glyph %s don't have the same name." %(anchorIndex, selfName, otherName)) + return not fatalError, errors + + def _interpolateContours(self, factor, minContours, maxContours): + newContours = [] + for contourIndex in xrange(len(minContours)): + minContour = minContours[contourIndex] + maxContour = maxContours[contourIndex] + newContours.append([]) + for pointIndex in xrange(len(minContour)): + segType, pt, smooth, name = minContour[pointIndex] + minPoint = minContour[pointIndex][1] + maxPoint = maxContour[pointIndex][1] + newX, newY = _interpolatePt(minPoint, maxPoint, factor) + newContours[-1].append((segType, (newX, newY), smooth, name)) + return newContours + + def _interpolateComponents(self, factor, minComponents, maxComponents): + newComponents = [] + minComponents, maxComponents = self._mathComponentCompare(minComponents, maxComponents) + componentNames = minComponents.keys() + for componentName in componentNames: + minComponentList = minComponents[componentName] + maxComponentList = maxComponents[componentName] + for i in xrange(len(minComponentList)): + # transformation breakdown: xScale, xyScale, yxScale, yScale, xOffset, yOffset + minXScale, minXYScale, minYXScale, minYScale, minXOffset, minYOffset = minComponentList[i] + maxXScale, maxXYScale, maxYXScale, maxYScale, maxXOffset, maxYOffset = maxComponentList[i] + newXScale, newXYScale = _interpolatePt((minXScale, minXYScale), (maxXScale, maxXYScale), factor) + newYXScale, newYScale = _interpolatePt((minYXScale, minYScale), (maxYXScale, maxYScale), factor) + newXOffset, newYOffset = _interpolatePt((minXOffset, minYOffset), (maxXOffset, maxYOffset), factor) + newComponents.append((componentName, (newXScale, newXYScale, newYXScale, newYScale, newXOffset, newYOffset))) + return newComponents + + def _interpolateAnchors(self, factor, minAnchors, maxAnchors): + newAnchors = [] + minAnchors, maxAnchors = self._mathAnchorCompare(minAnchors, maxAnchors) + anchorNames = minAnchors.keys() + for anchorName in anchorNames: + minAnchorList = minAnchors[anchorName] + maxAnchorList = maxAnchors[anchorName] + for i in range(len(minAnchorList)): + minAnchor = minAnchorList[i] + maxAnchor = maxAnchorList[i] + newAnchor = _interpolatePt(minAnchor, maxAnchor, factor) + newAnchors.append((newAnchor, anchorName)) + return newAnchors + + # + # comparisons + # + + def __eq__(self, other): + if isinstance(other, BaseGlyph): + return self._getDigest() == other._getDigest() + return False + + def __ne__(self, other): + return not self.__eq__(other) + + def _getDigest(self, pointsOnly=False): + """Calculate a digest of coordinates, points, things in this glyph. + With pointsOnly == True the digest consists of a flat tuple of all + coordinate pairs in the glyph, without the order of contours. + """ + from robofab.pens.digestPen import DigestPointPen + mp = DigestPointPen() + self.drawPoints(mp) + if pointsOnly: + return "%s|%d|%s"%(mp.getDigestPointsOnly(), self.width, self.unicode) + else: + return "%s|%d|%s"%(mp.getDigest(), self.width, self.unicode) + + def _getStructure(self): + """Calculate a digest of points, things in this glyph, but NOT coordinates.""" + from robofab.pens.digestPen import DigestPointStructurePen + mp = DigestPointStructurePen() + self.drawPoints(mp) + return mp.getDigest() + + def _hasChanged(self): + """mark the object and it's parent as changed""" + self.setChanged(True) + if self.getParent() is not None: + self.getParent()._hasChanged() + + def _get_box(self): + bounds = _box(self, fontObject=self.getParent()) + return bounds + + box = property(_get_box, doc="the bounding box of the glyph: (xMin, yMin, xMax, yMax)") + + def _get_leftMargin(self): + if self.isEmpty(): + return 0 + xMin, yMin, xMax, yMax = self.box + return xMin + + def _set_leftMargin(self, value): + if self.isEmpty(): + self.width = self.width + value + else: + diff = value - self.leftMargin + self.move((diff, 0)) + self.width = self.width + diff + + leftMargin = property(_get_leftMargin, _set_leftMargin, doc="the left margin") + + def _get_rightMargin(self): + if self.isEmpty(): + return self.width + xMin, yMin, xMax, yMax = self.box + return self.width - xMax + + def _set_rightMargin(self, value): + if self.isEmpty(): + self.width = value + else: + xMin, yMin, xMax, yMax = self.box + self.width = xMax + value + + rightMargin = property(_get_rightMargin, _set_rightMargin, doc="the right margin") + + def copy(self, aParent=None): + """Duplicate this glyph""" + n = self.__class__() + if aParent is not None: + n.setParent(aParent) + dont = ['_object', 'getParent'] + for k in self.__dict__.keys(): + ok = True + if k in dont: + continue + elif k == "contours": + dup = [] + for i in self.contours: + dup.append(i.copy(n)) + elif k == "components": + dup = [] + for i in self.components: + dup.append(i.copy(n)) + elif k == "anchors": + dup = [] + for i in self.anchors: + dup.append(i.copy(n)) + elif k == "psHints": + dup = self.psHints.copy() + elif isinstance(self.__dict__[k], (RBaseObject, BaseLib)): + dup = self.__dict__[k].copy(n) + else: + dup = copy.deepcopy(self.__dict__[k]) + if ok: + setattr(n, k, dup) + return n + + def _setParentTree(self): + """Set the parents of all contained and dependent objects (and their dependents) right.""" + for item in self.contours: + item.setParent(self) + item._setParentTree() + for item in self.components: + item.setParent(self) + for items in self.anchors: + item.setParent(self) + + def getGlyph(self, glyphName): + """Provided there is a font parent for this glyph, return a sibling glyph.""" + if glyphName == self.name: + return self + if self.getParent() is not None: + return self.getParent()[glyphName] + return None + + def getPen(self): + """Return a Pen object for creating an outline in this glyph.""" + from robofab.pens.adapterPens import SegmentToPointPen + return SegmentToPointPen(self.getPointPen()) + + def getPointPen(self): + """Return a PointPen object for creating an outline in this glyph.""" + raise NotImplementedError, "getPointPen() must be implemented by subclass" + + def deSelect(self): + """Set all selected attrs in glyph to False: for the glyph, components, anchors, points.""" + for a in self.anchors: + a.selected = False + for a in self.components: + a.selected = False + for c in self.contours: + for p in c.points: + p.selected = False + self.selected = False + + def isEmpty(self): + """return true if the glyph has no contours or components""" + if len(self.contours) + len(self.components) == 0: + return True + else: + return False + + def _saveToGlyphSet(self, glyphSet, glyphName=None, force=False): + """Save the glyph to GlyphSet, a private method that's part of the saving process.""" + # save stuff in the lib first + if force or self.changed: + if glyphName is None: + glyphName = self.name + glyphSet.writeGlyph(glyphName, self, self.drawPoints) + + def update(self): + """update the glyph""" + pass + + def draw(self, pen): + """draw the object with a RoboFab segment pen""" + try: + pen.setWidth(self.width) + if self.note is not None: + pen.setNote(self.note) + except AttributeError: + # FontTools pens don't have these methods + pass + for a in self.anchors: + a.draw(pen) + for c in self.contours: + c.draw(pen) + for c in self.components: + c.draw(pen) + try: + pen.doneDrawing() + except AttributeError: + # FontTools pens don't have a doneDrawing() method + pass + + def drawPoints(self, pen): + """draw the object with a point pen""" + for a in self.anchors: + a.drawPoints(pen) + for c in self.contours: + c.drawPoints(pen) + for c in self.components: + c.drawPoints(pen) + + def appendContour(self, aContour, offset=(0, 0)): + """append a contour to the glyph""" + x, y = offset + pen = self.getPointPen() + aContour.drawPoints(pen) + self.contours[-1].move((x, y)) + + def appendGlyph(self, aGlyph, offset=(0, 0)): + """append another glyph to the glyph""" + x, y = offset + pen = self.getPointPen() + #to handle the offsets, move the source glyph and then move it back! + aGlyph.move((x, y)) + aGlyph.drawPoints(pen) + aGlyph.move((-x, -y)) + + def round(self): + """round all coordinates in all contours, components and anchors""" + for n in self.contours: + n.round() + for n in self.components: + n.round() + for n in self.anchors: + n.round() + self.width = int(round(self.width)) + + def autoUnicodes(self): + """Using fontTools.agl, assign Unicode list to the glyph""" + from fontTools.agl import AGL2UV + if AGL2UV.has_key(self.name): + self.unicode = AGL2UV[self.name] + self._hasChanged() + + def pointInside(self, pt, evenOdd=0): + """determine if the point is in the black or white of the glyph""" + x, y = pt + from fontTools.pens.pointInsidePen import PointInsidePen + font = self.getParent() + piPen = PointInsidePen(glyphSet=font, testPoint=(x, y), evenOdd=evenOdd) + self.draw(piPen) + return piPen.getResult() + + def correctDirection(self, trueType=False): + """corect the direction of the contours in the glyph.""" + #this is a bit slow, but i'm not sure how much more it can be optimized. + #it also has a bug somewhere that is causeing some contours to be set incorrectly. + #try to run it on the copyright symbol to see the problem. hm. + # + #establish the default direction that an outer contour should follow + #i believe for TT this is clockwise and for PS it is counter + #i could be wrong about this, i need to double check. + from fontTools.pens.pointInsidePen import PointInsidePen + baseDirection = 0 + if trueType: + baseDirection = 1 + #we don't need to do all the work if the contour count is < 2 + count = len(self.contours) + if count == 0: + return + elif count == 1: + self.contours[0].clockwise = baseDirection + return + #store up needed before we start + #i think the .box calls are eating a big chunk of the time + contourDict = {} + for contourIndex in range(len(self.contours)): + contour = self.contours[contourIndex] + contourDict[contourIndex] = {'box':contour.box, 'dir':contour.clockwise, 'hit':[], 'notHit':[]} + #now, for every contour, determine which contours it intersects + #as we go, we will also store contours that it doesn't intersct + #and we store this value for both contours + allIndexes = contourDict.keys() + for contourIndex in allIndexes: + for otherContourIndex in allIndexes: + if otherContourIndex != contourIndex: + if contourIndex not in contourDict[otherContourIndex]['hit'] and contourIndex not in contourDict[otherContourIndex]['notHit']: + xMin1, yMin1, xMax1, yMax1 = contourDict[contourIndex]['box'] + xMin2, yMin2, xMax2, yMax2= contourDict[otherContourIndex]['box'] + hit, pos = sectRect((xMin1, yMin1, xMax1, yMax1), (xMin2, yMin2, xMax2, yMax2)) + if hit == 1: + contourDict[contourIndex]['hit'].append(otherContourIndex) + contourDict[otherContourIndex]['hit'].append(contourIndex) + else: + contourDict[contourIndex]['notHit'].append(otherContourIndex) + contourDict[otherContourIndex]['notHit'].append(contourIndex) + #set up the pen here to shave a bit of time + font = self.getParent() + piPen = PointInsidePen(glyphSet=font, testPoint=(0, 0), evenOdd=0) + #now do the pointInside work + for contourIndex in allIndexes: + direction = baseDirection + contour = self.contours[contourIndex] + startPoint = contour.segments[0].onCurve + if startPoint is not None: #skip TT paths with no onCurve + if len(contourDict[contourIndex]['hit']) != 0: + for otherContourIndex in contourDict[contourIndex]['hit']: + piPen.setTestPoint(testPoint=(startPoint.x, startPoint.y)) + otherContour = self.contours[otherContourIndex] + otherContour.draw(piPen) + direction = direction + piPen.getResult() + newDirection = direction % 2 + #now set the direction if we need to + if newDirection != contourDict[contourIndex]['dir']: + contour.reverseContour() + + def autoContourOrder(self): + """attempt to sort the contours based on their centers""" + # sort is based on (in this order): + # - the (negative) point count + # - the (negative) segment count + # - fuzzy x value of the center of the contour + # - fuzzy y value of the center of the contour + # - the (negative) surface of the bounding box of the contour: width * height + # the latter is a safety net for for instances like a very thin 'O' where the + # x centers could be close enough to rely on the y for the sort which could + # very well be the same for both contours. We use the _negative_ of the surface + # to ensure that larger contours appear first, which seems more natural. + tempContourList = [] + contourList = [] + xThreshold = None + yThreshold = None + for contour in self.contours: + xMin, yMin, xMax, yMax = contour.box + width = xMax - xMin + height = yMax - yMin + xC = 0.5 * (xMin + xMax) + yC = 0.5 * (yMin + yMax) + xTh = abs(width * .5) + yTh = abs(height * .5) + if xThreshold is None or xThreshold > xTh: + xThreshold = xTh + if yThreshold is None or yThreshold > yTh: + yThreshold = yTh + tempContourList.append((-len(contour.points), -len(contour.segments), xC, yC, -(width * height), contour)) + for points, segments, x, y, surface, contour in tempContourList: + contourList.append((points, segments, FuzzyNumber(x, xThreshold), FuzzyNumber(y, yThreshold), surface, contour)) + contourList.sort() + for i in range(len(contourList)): + points, segments, xO, yO, surface, contour = contourList[i] + contour.index = i + + def rasterize(self, cellSize=50, xMin=None, yMin=None, xMax=None, yMax=None): + """ + Slice the glyph into a grid based on the cell size. + It returns a list of lists containing bool values + that indicate the black (True) or white (False) + value of that particular cell. These lists are + arranged from top to bottom of the glyph and + proceed from left to right. + This is an expensive operation! + """ + from fontTools.pens.pointInsidePen import PointInsidePen + piPen = PointInsidePen(glyphSet=self.getParent(), testPoint=(0, 0), evenOdd=0) + if xMin is None or yMin is None or xMax is None or yMax is None: + _xMin, _yMin, _xMax, _yMax = self.box + if xMin is None: + xMin = _xMin + if yMin is None: + yMin = _yMin + if xMax is None: + xMax = _xMax + if yMax is None: + yMax = _yMax + # + hitXMax = False + hitYMin = False + xSlice = 0 + ySlice = 0 + halfCellSize = cellSize / 2.0 + # + map = [] + # + while not hitYMin: + map.append([]) + yScan = -(ySlice * cellSize) + yMax - halfCellSize + if yScan < yMin: + hitYMin = True + while not hitXMax: + xScan = (xSlice * cellSize) + xMin - halfCellSize + if xScan > xMax: + hitXMax = True + piPen.setTestPoint((xScan, yScan)) + self.draw(piPen) + test = piPen.getResult() + if test: + map[-1].append(True) + else: + map[-1].append(False) + xSlice = xSlice + 1 + hitXMax = False + xSlice = 0 + ySlice = ySlice + 1 + return map + + def move(self, pt, contours=True, components=True, anchors=True): + """Move a glyph's items that are flagged as True""" + x, y = roundPt(pt) + if contours: + for contour in self.contours: + contour.move((x, y)) + if components: + for component in self.components: + component.move((x, y)) + if anchors: + for anchor in self.anchors: + anchor.move((x, y)) + + def scale(self, pt, center=(0, 0)): + """scale the glyph""" + x, y = pt + for contour in self.contours: + contour.scale((x, y), center=center) + for component in self.components: + offset = component.offset + component.offset = _scalePointFromCenter(offset, pt, center) + sX, sY = component.scale + component.scale = (sX*x, sY*y) + for anchor in self.anchors: + anchor.scale((x, y), center=center) + + def transform(self, matrix): + """Transform this glyph. + Use a Transform matrix object from + robofab.transform""" + n = [] + for c in self.contours: + c.transform(matrix) + for a in self.anchors: + a.transform(matrix) + + def rotate(self, angle, offset=None): + """rotate the glyph""" + from fontTools.misc.transform import Identity + radAngle = angle / DEGREE # convert from degrees to radians + if offset is None: + offset = (0,0) + rT = Identity.translate(offset[0], offset[1]) + rT = rT.rotate(radAngle) + rT = rT.translate(-offset[0], -offset[1]) + self.transform(rT) + + def skew(self, angle, offset=None): + """skew the glyph""" + from fontTools.misc.transform import Identity + radAngle = angle / DEGREE # convert from degrees to radians + if offset is None: + offset = (0,0) + rT = Identity.translate(offset[0], offset[1]) + rT = rT.skew(radAngle) + self.transform(rT) + + +class BaseContour(RBaseObject): + + """Base class for all contour objects.""" + + def __init__(self): + RBaseObject.__init__(self) + #self.index = None + self.changed = False # if the object needs to be saved + + def __repr__(self): + font = "unnamed_font" + glyph = "unnamed_glyph" + glyphParent = self.getParent() + if glyphParent is not None: + try: + glyph = glyphParent.name + except AttributeError: pass + fontParent = glyphParent.getParent() + if fontParent is not None: + try: + font = fontParent.info.postscriptFullName + except AttributeError: pass + try: + idx = `self.index` + except ValueError: + # XXXX + idx = "XXX" + return "<RContour for %s.%s[%s]>"%(font, glyph, idx) + + def __len__(self): + return len(self.segments) + + def __mul__(self, factor): + warn("Contour math has been deprecated and is slated for removal.", DeprecationWarning) + n = self.copy() + n.segments = [] + for i in range(len(self.segments)): + n.segments.append(self.segments[i] * factor) + n._setParentTree() + return n + + __rmul__ = __mul__ + + def __add__(self, other): + warn("Contour math has been deprecated and is slated for removal.", DeprecationWarning) + n = self.copy() + n.segments = [] + for i in range(len(self.segments)): + n.segments.append(self.segments[i] + other.segments[i]) + n._setParentTree() + return n + + def __sub__(self, other): + warn("Contour math has been deprecated and is slated for removal.", DeprecationWarning) + n = self.copy() + n.segments = [] + for i in range(len(self.segments)): + n.segments.append(self.segments[i] - other.segments[i]) + n._setParentTree() + return n + + def __getitem__(self, index): + return self.segments[index] + + def _hasChanged(self): + """mark the object and it's parent as changed""" + self.setChanged(True) + if self.getParent() is not None: + self.getParent()._hasChanged() + + def _nextSegment(self, segmentIndex): + return self.segments[(segmentIndex + 1) % len(self.segments)] + + def _prevSegment(self, segmentIndex): + segments = self.segments + return self.segments[(segmentIndex - 1) % len(self.segments)] + + def _get_box(self): + bounds = _box(self) + return bounds + + box = property(_get_box, doc="the bounding box for the contour") + + def _set_clockwise(self, value): + if self.clockwise != value: + self.reverseContour() + + def _get_clockwise(self): + pen = AreaPen(self) + self.draw(pen) + return pen.value < 0 + + clockwise = property(_get_clockwise, _set_clockwise, doc="direction of contour: positive=counterclockwise negative=clockwise") + + def copy(self, aParent=None): + """Duplicate this contour""" + n = self.__class__() + if aParent is not None: + n.setParent(aParent) + elif self.getParent() is not None: + n.setParent(self.getParent()) + dont = ['_object', 'points', 'bPoints', 'getParent'] + for k in self.__dict__.keys(): + ok = True + if k in dont: + continue + elif k == "segments": + dup = [] + for i in self.segments: + dup.append(i.copy(n)) + elif isinstance(self.__dict__[k], (RBaseObject, BaseLib)): + dup = self.__dict__[k].copy(n) + else: + dup = copy.deepcopy(self.__dict__[k]) + if ok: + setattr(n, k, dup) + return n + + def _setParentTree(self): + """Set the parents of all contained and dependent objects (and their dependents) right.""" + for item in self.segments: + item.setParent(self) + + def round(self): + """round the value of all points in the contour""" + for n in self.points: + n.round() + + def draw(self, pen): + """draw the object with a fontTools pen""" + firstOn = self.segments[0].onCurve + firstType = self.segments[0].type + lastOn = self.segments[-1].onCurve + # this is a special exception for FontLab + # FL can have a contour that does not contain a move. + # this will only happen if the contour begins with a qcurve. + # in this case, we move to the segment's on curve, + # then we iterate through the rest of the points, + # then we add the first qcurve and finally we + # close the path. after this, i say "ugh." + if firstType == QCURVE: + pen.moveTo((firstOn.x, firstOn.y)) + for segment in self.segments[1:]: + segmentType = segment.type + pt = segment.onCurve.x, segment.onCurve.y + if segmentType == LINE: + pen.lineTo(pt) + elif segmentType == CURVE: + pts = [(point.x, point.y) for point in segment.points] + pen.curveTo(*pts) + elif segmentType == QCURVE: + pts = [(point.x, point.y) for point in segment.points] + pen.qCurveTo(*pts) + else: + assert 0, "unsupported segment type" + pts = [(point.x, point.y) for point in self.segments[0].points] + pen.qCurveTo(*pts) + pen.closePath() + else: + if firstType == MOVE and (firstOn.x, firstOn.y) == (lastOn.x, lastOn.y): + closed = True + else: + closed = True + for segment in self.segments: + segmentType = segment.type + pt = segment.onCurve.x, segment.onCurve.y + if segmentType == MOVE: + pen.moveTo(pt) + elif segmentType == LINE: + pen.lineTo(pt) + elif segmentType == CURVE: + pts = [(point.x, point.y) for point in segment.points] + pen.curveTo(*pts) + elif segmentType == QCURVE: + pts = [(point.x, point.y) for point in segment.points] + pen.qCurveTo(*pts) + else: + assert 0, "unsupported segment type" + if closed: + pen.closePath() + else: + pen.endPath() + + def drawPoints(self, pen): + """draw the object with a point pen""" + pen.beginPath() + lastOn = self.segments[-1].onCurve + didLastOn = False + flQCurveException = False + lastIndex = len(self.segments) - 1 + for i in range(len(self.segments)): + segment = self.segments[i] + segmentType = segment.type + # the new protocol states that we start with an onCurve + # so, if we have a move and a nd a last point overlapping, + # add the last point to the beginning and skip the move + if segmentType == MOVE and (segment.onCurve.x, segment.onCurve.y) == (lastOn.x, lastOn.y): + point = self.segments[-1].onCurve + name = getattr(segment.onCurve, 'name', None) + pen.addPoint((point.x, point.y), point.type, smooth=self.segments[-1].smooth, name=name) + didLastOn = True + continue + # this is an exception for objectsFL + # the problem is that quad contours are + # represented differently that they are in + # objectsRF: + # FL: [qcurve, qcurve, qcurve, qcurve] + # RF: [move, qcurve, qcurve, qcurve, qcurve] + # so, we need to catch this, and shift the offCurves to + # to the end of the contour + if i == 0 and segmentType == QCURVE: + flQCurveException = True + if segmentType == MOVE: + segmentType = LINE + ## the offCurves + if i == 0 and flQCurveException: + pass + else: + for point in segment.offCurve: + name = getattr(point, 'name', None) + pen.addPoint((point.x, point.y), segmentType=None, smooth=None, name=name, selected=point.selected) + ## the onCurve + # skip the last onCurve if it was used as the move + if i == lastIndex and didLastOn: + continue + point = segment.onCurve + name = getattr(point, 'name', None) + pen.addPoint((point.x, point.y), segmentType, smooth=segment.smooth, name=name, selected=point.selected) + # if we have the special qCurve case with objectsFL + # take care of the offCurves associated with the first contour + if flQCurveException: + for point in self.segments[0].offCurve: + name = getattr(point, 'name', None) + pen.addPoint((point.x, point.y), segmentType=None, smooth=None, name=name, selected=point.selected) + pen.endPath() + + def move(self, pt): + """move the contour""" + #this will be faster if we go straight to the points + for point in self.points: + point.move(pt) + + def scale(self, pt, center=(0, 0)): + """scale the contour""" + #this will be faster if we go straight to the points + for point in self.points: + point.scale(pt, center=center) + + def transform(self, matrix): + """Transform this contour. + Use a Transform matrix object from + robofab.transform""" + n = [] + for s in self.segments: + s.transform(matrix) + + def rotate(self, angle, offset=None): + """rotate the contour""" + from fontTools.misc.transform import Identity + radAngle = angle / DEGREE # convert from degrees to radians + if offset is None: + offset = (0,0) + rT = Identity.translate(offset[0], offset[1]) + rT = rT.rotate(radAngle) + self.transform(rT) + + def skew(self, angle, offset=None): + """skew the contour""" + from fontTools.misc.transform import Identity + radAngle = angle / DEGREE # convert from degrees to radians + if offset is None: + offset = (0,0) + rT = Identity.translate(offset[0], offset[1]) + rT = rT.skew(radAngle) + self.transform(rT) + + def pointInside(self, pt, evenOdd=0): + """determine if the point is inside or ouside of the contour""" + from fontTools.pens.pointInsidePen import PointInsidePen + glyph = self.getParent() + font = glyph.getParent() + piPen = PointInsidePen(glyphSet=font, testPoint=pt, evenOdd=evenOdd) + self.draw(piPen) + return piPen.getResult() + + def autoStartSegment(self): + """automatically set the lower left point of the contour as the first point.""" + #adapted from robofog + startIndex = 0 + startSegment = self.segments[0] + for i in range(len(self.segments)): + segment = self.segments[i] + startOn = startSegment.onCurve + on = segment.onCurve + if on.y <= startOn.y: + if on.y == startOn.y: + if on.x < startOn.x: + startSegment = segment + startIndex = i + else: + startSegment = segment + startIndex = i + if startIndex != 0: + self.setStartSegment(startIndex) + + def appendBPoint(self, pointType, anchor, bcpIn=(0, 0), bcpOut=(0, 0)): + """append a bPoint to the contour""" + self.insertBPoint(len(self.segments), pointType=pointType, anchor=anchor, bcpIn=bcpIn, bcpOut=bcpOut) + + def insertBPoint(self, index, pointType, anchor, bcpIn=(0, 0), bcpOut=(0, 0)): + """insert a bPoint at index on the contour""" + #insert a CURVE point that we can work with + nextSegment = self._nextSegment(index-1) + if nextSegment.type == QCURVE: + return + if nextSegment.type == MOVE: + prevSegment = self.segments[index-1] + prevOn = prevSegment.onCurve + if bcpIn != (0, 0): + new = self.appendSegment(CURVE, [(prevOn.x, prevOn.y), absoluteBCPIn(anchor, bcpIn), anchor], smooth=False) + if pointType == CURVE: + new.smooth = True + else: + new = self.appendSegment(LINE, [anchor], smooth=False) + #if the user wants an outgoing bcp, we must add a CURVE ontop of the move + if bcpOut != (0, 0): + nextOn = nextSegment.onCurve + self.appendSegment(CURVE, [absoluteBCPOut(anchor, bcpOut), (nextOn.x, nextOn.y), (nextOn.x, nextOn.y)], smooth=False) + else: + #handle the bcps + if nextSegment.type != CURVE: + prevSegment = self.segments[index-1] + prevOn = prevSegment.onCurve + prevOutX, prevOutY = (prevOn.x, prevOn.y) + else: + prevOut = nextSegment.offCurve[0] + prevOutX, prevOutY = (prevOut.x, prevOut.y) + self.insertSegment(index, segmentType=CURVE, points=[(prevOutX, prevOutY), anchor, anchor], smooth=False) + newSegment = self.segments[index] + prevSegment = self._prevSegment(index) + nextSegment = self._nextSegment(index) + if nextSegment.type == MOVE: + raise RoboFabError, 'still working out curving at the end of a contour' + elif nextSegment.type == QCURVE: + return + #set the new incoming bcp + newIn = newSegment.offCurve[1] + nIX, nIY = absoluteBCPIn(anchor, bcpIn) + newIn.x = nIX + newIn.y = nIY + #set the new outgoing bcp + hasCurve = True + if nextSegment.type != CURVE: + if bcpOut != (0, 0): + nextSegment.type = CURVE + hasCurve = True + else: + hasCurve = False + if hasCurve: + newOut = nextSegment.offCurve[0] + nOX, nOY = absoluteBCPOut(anchor, bcpOut) + newOut.x = nOX + newOut.y = nOY + #now check to see if we can convert the CURVE segment to a LINE segment + newAnchor = newSegment.onCurve + newA = newSegment.offCurve[0] + newB = newSegment.offCurve[1] + nextAnchor = nextSegment.onCurve + prevAnchor = prevSegment.onCurve + if (prevAnchor.x, prevAnchor.y) == (newA.x, newA.y) and (newAnchor.x, newAnchor.y) == (newB.x, newB.y): + newSegment.type = LINE + #the user wants a smooth segment + if pointType == CURVE: + newSegment.smooth = True + + +class BaseSegment(RBaseObject): + + """Base class for all segment objects""" + + def __init__(self): + self.changed = False + + def __repr__(self): + font = "unnamed_font" + glyph = "unnamed_glyph" + contourIndex = "unknown_contour" + contourParent = self.getParent() + if contourParent is not None: + try: + contourIndex = `contourParent.index` + except AttributeError: pass + glyphParent = contourParent.getParent() + if glyphParent is not None: + try: + glyph = glyphParent.name + except AttributeError: pass + fontParent = glyphParent.getParent() + if fontParent is not None: + try: + font = fontParent.info.postscriptFullName + except AttributeError: pass + try: + idx = `self.index` + except ValueError: + idx = "XXX" + return "<RSegment for %s.%s[%s][%s]>"%(font, glyph, contourIndex, idx) + + def __mul__(self, factor): + warn("Segment math has been deprecated and is slated for removal.", DeprecationWarning) + n = self.copy() + n.points = [] + for i in range(len(self.points)): + n.points.append(self.points[i] * factor) + n._setParentTree() + return n + + __rmul__ = __mul__ + + def __add__(self, other): + warn("Segment math has been deprecated and is slated for removal.", DeprecationWarning) + n = self.copy() + n.points = [] + for i in range(len(self.points)): + n.points.append(self.points[i] + other.points[i]) + return n + + def __sub__(self, other): + warn("Segment math has been deprecated and is slated for removal.", DeprecationWarning) + n = self.copy() + n.points = [] + for i in range(len(self.points)): + n.points.append(self.points[i] - other.points[i]) + return n + + def _hasChanged(self): + """mark the object and it's parent as changed""" + self.setChanged(True) + if self.getParent() is not None: + self.getParent()._hasChanged() + + def copy(self, aParent=None): + """Duplicate this segment""" + n = self.__class__() + if aParent is not None: + n.setParent(aParent) + elif self.getParent() is not None: + n.setParent(self.getParent()) + dont = ['_object', 'getParent', 'offCurve', 'onCurve'] + for k in self.__dict__.keys(): + ok = True + if k in dont: + continue + if k == "points": + dup = [] + for i in self.points: + dup.append(i.copy(n)) + elif isinstance(self.__dict__[k], (RBaseObject, BaseLib)): + dup = self.__dict__[k].copy(n) + else: + dup = copy.deepcopy(self.__dict__[k]) + if ok: + setattr(n, k, dup) + return n + + def _setParentTree(self): + """Set the parents of all contained and dependent objects (and their dependents) right.""" + for item in self.points: + item.setParent(self) + + def round(self): + """round all points in the segment""" + for point in self.points: + point.round() + + def move(self, pt): + """move the segment""" + for point in self.points: + point.move(pt) + + def scale(self, pt, center=(0, 0)): + """scale the segment""" + for point in self.points: + point.scale(pt, center=center) + + def transform(self, matrix): + """Transform this segment. + Use a Transform matrix object from + robofab.transform""" + n = [] + for p in self.points: + p.transform(matrix) + + def _get_onCurve(self): + return self.points[-1] + + def _get_offCurve(self): + return self.points[:-1] + + offCurve = property(_get_offCurve, doc="on curve point for the segment") + onCurve = property(_get_onCurve, doc="list of off curve points for the segment") + + + +class BasePoint(RBaseObject): + + """Base class for point objects.""" + + def __init__(self): + #RBaseObject.__init__(self) + self.changed = False # if the object needs to be saved + self.selected = False + + def __repr__(self): + font = "unnamed_font" + glyph = "unnamed_glyph" + contourIndex = "unknown_contour" + segmentIndex = "unknown_segment" + segmentParent = self.getParent() + if segmentParent is not None: + try: + segmentIndex = `segmentParent.index` + except AttributeError: pass + contourParent = self.getParent().getParent() + if contourParent is not None: + try: + contourIndex = `contourParent.index` + except AttributeError: pass + glyphParent = contourParent.getParent() + if glyphParent is not None: + try: + glyph = glyphParent.name + except AttributeError: pass + fontParent = glyphParent.getParent() + if fontParent is not None: + try: + font = fontParent.info.postscriptFullName + except AttributeError: pass + return "<RPoint for %s.%s[%s][%s]>"%(font, glyph, contourIndex, segmentIndex) + + def __add__(self, other): + warn("Point math has been deprecated and is slated for removal.", DeprecationWarning) + #Add one point to another + n = self.copy() + n.x, n.y = addPt((self.x, self.y), (other.x, other.y)) + return n + + def __sub__(self, other): + warn("Point math has been deprecated and is slated for removal.", DeprecationWarning) + #Subtract one point from another + n = self.copy() + n.x, n.y = subPt((self.x, self.y), (other.x, other.y)) + return n + + def __mul__(self, factor): + warn("Point math has been deprecated and is slated for removal.", DeprecationWarning) + #Multiply the point with factor. Factor can be a tuple of 2 *(f1, f2) + n = self.copy() + n.x, n.y = mulPt((self.x, self.y), factor) + return n + + __rmul__ = __mul__ + + def _hasChanged(self): + #mark the object and it's parent as changed + self.setChanged(True) + if self.getParent() is not None: + self.getParent()._hasChanged() + + def copy(self, aParent=None): + """Duplicate this point""" + n = self.__class__() + if aParent is not None: + n.setParent(aParent) + elif self.getParent() is not None: + n.setParent(self.getParent()) + dont = ['getParent', 'offCurve', 'onCurve'] + for k in self.__dict__.keys(): + ok = True + if k in dont: + continue + elif isinstance(self.__dict__[k], (RBaseObject, BaseLib)): + dup = self.__dict__[k].copy(n) + else: + dup = copy.deepcopy(self.__dict__[k]) + if ok: + setattr(n, k, dup) + return n + + def select(self, state=True): + """Set the selection of this point. + XXXX This method should be a lot more versatile, dealing with + different kinds of selection, select the bcp's seperately etc. + But that's for later when we need it more. For now it's just + one flag for the entire thing.""" + self.selected = state + + def round(self): + """round the values in the point""" + self.x, self.y = roundPt((self.x, self.y)) + + def move(self, pt): + """Move the point""" + self.x, self.y = addPt((self.x, self.y), pt) + + def scale(self, pt, center=(0, 0)): + """scale the point""" + nX, nY = _scalePointFromCenter((self.x, self.y), pt, center) + self.x = nX + self.y = nY + + def transform(self, matrix): + """Transform this point. Use a Transform matrix + object from fontTools.misc.transform""" + self.x, self.y = matrix.transformPoint((self.x, self.y)) + + +class BaseBPoint(RBaseObject): + + """Base class for bPoints objects.""" + + def __init__(self): + RBaseObject.__init__(self) + self.changed = False # if the object needs to be saved + self.selected = False + + def __repr__(self): + font = "unnamed_font" + glyph = "unnamed_glyph" + contourIndex = "unknown_contour" + segmentIndex = "unknown_segment" + segmentParent = self.getParent() + if segmentParent is not None: + try: + segmentIndex = `segmentParent.index` + except AttributeError: pass + contourParent = segmentParent.getParent() + if contourParent is not None: + try: + contourIndex = `contourParent.index` + except AttributeError: pass + glyphParent = contourParent.getParent() + if glyphParent is not None: + try: + glyph = glyphParent.name + except AttributeError: pass + fontParent = glyphParent.getParent() + if fontParent is not None: + try: + font = fontParent.info.postscriptFullName + except AttributeError: pass + return "<RBPoint for %s.%s[%s][%s][%s]>"%(font, glyph, contourIndex, segmentIndex, `self.index`) + + + def __add__(self, other): + warn("BPoint math has been deprecated and is slated for removal.", DeprecationWarning) + #Add one bPoint to another + n = self.copy() + n.anchor = addPt(self.anchor, other.anchor) + n.bcpIn = addPt(self.bcpIn, other.bcpIn) + n.bcpOut = addPt(self.bcpOut, other.bcpOut) + return n + + def __sub__(self, other): + warn("BPoint math has been deprecated and is slated for removal.", DeprecationWarning) + #Subtract one bPoint from another + n = self.copy() + n.anchor = subPt(self.anchor, other.anchor) + n.bcpIn = subPt(self.bcpIn, other.bcpIn) + n.bcpOut = subPt(self.bcpOut, other.bcpOut) + return n + + def __mul__(self, factor): + warn("BPoint math has been deprecated and is slated for removal.", DeprecationWarning) + #Multiply the bPoint with factor. Factor can be a tuple of 2 *(f1, f2) + n = self.copy() + n.anchor = mulPt(self.anchor, factor) + n.bcpIn = mulPt(self.bcpIn, factor) + n.bcpOut = mulPt(self.bcpOut, factor) + return n + + __rmul__ = __mul__ + + def _hasChanged(self): + #mark the object and it's parent as changed + self.setChanged(True) + if self.getParent() is not None: + self.getParent()._hasChanged() + + def select(self, state=True): + """Set the selection of this point. + XXXX This method should be a lot more versatile, dealing with + different kinds of selection, select the bcp's seperately etc. + But that's for later when we need it more. For now it's just + one flag for the entire thing.""" + self.selected = state + + def round(self): + """Round the coordinates to integers""" + self.anchor = roundPt(self.anchor) + pSeg = self._parentSegment + if pSeg.type != MOVE: + self.bcpIn = roundPt(self.bcpIn) + if pSeg.getParent()._nextSegment(pSeg.index).type != MOVE: + self.bcpOut = roundPt(self.bcpOut) + + def move(self, pt): + """move the bPoint""" + x, y = pt + bcpIn = self.bcpIn + bcpOut = self.bcpOut + self.anchor = (self.anchor[0] + x, self.anchor[1] + y) + pSeg = self._parentSegment + if pSeg.type != MOVE: + self.bcpIn = bcpIn + if pSeg.getParent()._nextSegment(pSeg.index).type != MOVE: + self.bcpOut = bcpOut + + def scale(self, pt, center=(0, 0)): + """scale the bPoint""" + x, y = pt + centerX, centerY = center + ogCenter = (centerX, centerY) + scaledCenter = (centerX * x, centerY * y) + shiftVal = (scaledCenter[0] - ogCenter[0], scaledCenter[1] - ogCenter[1]) + anchor = self.anchor + bcpIn = self.bcpIn + bcpOut = self.bcpOut + self.anchor = ((anchor[0] * x) - shiftVal[0], (anchor[1] * y) - shiftVal[1]) + pSeg = self._parentSegment + if pSeg.type != MOVE: + self.bcpIn = ((bcpIn[0] * x), (bcpIn[1] * y)) + if pSeg.getParent()._nextSegment(pSeg.index).type != MOVE: + self.bcpOut = ((bcpOut[0] * x), (bcpOut[1] * y)) + + def transform(self, matrix): + """Transform this point. Use a Transform matrix + object from fontTools.misc.transform""" + self.anchor = matrix.transformPoint(self.anchor) + pSeg = self._parentSegment + if pSeg.type != MOVE: + self.bcpIn = matrix.transformPoint(self.bcpIn) + if pSeg.getParent()._nextSegment(pSeg.index).type != MOVE: + self.bcpOut = matrix.transformPoint(self.bcpOut) + + def _get__anchorPoint(self): + return self._parentSegment.onCurve + + _anchorPoint = property(_get__anchorPoint, doc="the oncurve point in the parent segment") + + def _get_anchor(self): + point = self._anchorPoint + return (point.x, point.y) + + def _set_anchor(self, value): + x, y = value + point = self._anchorPoint + point.x = x + point.y = y + + anchor = property(_get_anchor, _set_anchor, doc="the position of the anchor") + + def _get_bcpIn(self): + pSeg = self._parentSegment + pCount = len(pSeg.offCurve) + if pCount == 2: + p = pSeg.offCurve[1] + pOn = pSeg.onCurve + return relativeBCPIn((pOn.x, pOn.y), (p.x, p.y)) + else: + return (0, 0) + + def _set_bcpIn(self, value): + x, y = (absoluteBCPIn(self.anchor, value)) + pSeg = self._parentSegment + if pSeg.type == MOVE: + #the user wants to have a bcp leading into the MOVE + if value == (0, 0) and self.bcpOut == (0, 0): + #we have a straight line between the two anchors + pass + else: + #we need to insert a new CURVE segment ontop of the move + contour = self._parentSegment.getParent() + #set the prev segment outgoing bcp to the onCurve + prevSeg = contour._prevSegment(self._parentSegment.index) + prevOn = prevSeg.onCurve + contour.appendSegment(CURVE, [(prevOn.x, prevOn.y), (x, y), self.anchor], smooth=False) + else: + pCount = len(pSeg.offCurve) + if pCount == 2: + #if the two points in the offCurvePoints list are located at the + #anchor coordinates we can switch to a LINE segment type + if value == (0, 0) and self.bcpOut == (0, 0): + pSeg.type = LINE + pSeg.smooth = False + else: + pSeg.offCurve[1].x = x + pSeg.offCurve[1].y = y + elif value != (0, 0): + pSeg.type = CURVE + pSeg.offCurve[1].x = x + pSeg.offCurve[1].y = y + + bcpIn = property(_get_bcpIn, _set_bcpIn, doc="the (x,y) for the incoming bcp") + + def _get_bcpOut(self): + pSeg = self._parentSegment + nextSeg = pSeg.getParent()._nextSegment(pSeg.index) + nsCount = len(nextSeg.offCurve) + if nsCount == 2: + p = nextSeg.offCurve[0] + return relativeBCPOut(self.anchor, (p.x, p.y)) + else: + return (0, 0) + + def _set_bcpOut(self, value): + x, y = (absoluteBCPOut(self.anchor, value)) + pSeg = self._parentSegment + nextSeg = pSeg.getParent()._nextSegment(pSeg.index) + if nextSeg.type == MOVE: + if value == (0, 0) and self.bcpIn == (0, 0): + pass + else: + #we need to insert a new CURVE segment ontop of the move + contour = self._parentSegment.getParent() + nextOn = nextSeg.onCurve + contour.appendSegment(CURVE, [(x, y), (nextOn.x, nextOn.y), (nextOn.x, nextOn.y)], smooth=False) + else: + nsCount = len(nextSeg.offCurve) + if nsCount == 2: + #if the two points in the offCurvePoints list are located at the + #anchor coordinates we can switch to a LINE segment type + if value == (0, 0) and self.bcpIn == (0, 0): + nextSeg.type = LINE + nextSeg.smooth = False + else: + nextSeg.offCurve[0].x = x + nextSeg.offCurve[0].y = y + elif value != (0, 0): + nextSeg.type = CURVE + nextSeg.offCurve[0].x = x + nextSeg.offCurve[0].y = y + + bcpOut = property(_get_bcpOut, _set_bcpOut, doc="the (x,y) for the outgoing bcp") + + def _get_type(self): + pType = self._parentSegment.type + bpType = CORNER + if pType == CURVE: + if self._parentSegment.smooth: + bpType = CURVE + return bpType + + def _set_type(self, pointType): + pSeg = self._parentSegment + segType = pSeg.type + #user wants a curve where there is a line + if pointType == CURVE and segType == LINE: + pSeg.type = CURVE + pSeg.smooth = True + #the anchor is a curve segment. so, all we need to do is turn the smooth off + elif pointType == CORNER and segType == CURVE: + pSeg.smooth = False + + type = property(_get_type, _set_type, doc="the type of bPoint, either 'corner' or 'curve'") + + +class BaseComponent(RBaseObject): + + """Base class for all component objects.""" + + def __init__(self): + RBaseObject.__init__(self) + self.changed = False # if the object needs to be saved + self.selected = False + + def __repr__(self): + font = "unnamed_font" + glyph = "unnamed_glyph" + glyphParent = self.getParent() + if glyphParent is not None: + try: + glyph = glyphParent.name + except AttributeError: pass + fontParent = glyphParent.getParent() + if fontParent is not None: + try: + font = fontParent.info.postscriptFullName + except AttributeError: pass + return "<RComponent for %s.%s.components[%s]>"%(font, glyph, `self.index`) + + def _hasChanged(self): + """mark the object and it's parent as changed""" + self.setChanged(True) + if self.getParent() is not None: + self.getParent()._hasChanged() + + def copy(self, aParent=None): + """Duplicate this component.""" + n = self.__class__() + if aParent is not None: + n.setParent(aParent) + elif self.getParent() is not None: + n.setParent(self.getParent()) + dont = ['getParent', '_object'] + for k in self.__dict__.keys(): + if k in dont: + continue + elif isinstance(self.__dict__[k], (RBaseObject, BaseLib)): + dup = self.__dict__[k].copy(n) + else: + dup = copy.deepcopy(self.__dict__[k]) + setattr(n, k, dup) + return n + + def __add__(self, other): + warn("Component math has been deprecated and is slated for removal.", DeprecationWarning) + #Add one Component to another + n = self.copy() + n.offset = addPt(self.offset, other.offset) + n.scale = addPt(self.scale, other.scale) + return n + + def __sub__(self, other): + warn("Component math has been deprecated and is slated for removal.", DeprecationWarning) + #Subtract one Component from another + n = self.copy() + n.offset = subPt(self.offset, other.offset) + n.scale = subPt(self.scale, other.scale) + return n + + def __mul__(self, factor): + warn("Component math has been deprecated and is slated for removal.", DeprecationWarning) + #Multiply the Component with factor. Factor can be a tuple of 2 *(f1, f2) + n = self.copy() + n.offset = mulPt(self.offset, factor) + n.scale = mulPt(self.scale, factor) + return n + + __rmul__ = __mul__ + + def _get_box(self): + parentGlyph = self.getParent() + # the component is an orphan + if parentGlyph is None: + return None + parentFont = parentGlyph.getParent() + # the glyph that contains the component + # does not hae a parent + if parentFont is None: + return None + # the font does not have a glyph + # that matches the glyph that + # this component references + if not parentFont.has_key(self.baseGlyph): + return None + return _box(self, parentFont) + + box = property(_get_box, doc="the bounding box of the component: (xMin, yMin, xMax, yMax)") + + def round(self): + """round the offset values""" + self.offset = roundPt(self.offset) + self._hasChanged() + + def draw(self, pen): + """Segment pen drawing method.""" + if isinstance(pen, AbstractPen): + # It's a FontTools pen, which for addComponent is identical + # to PointPen. + self.drawPoints(pen) + else: + # It's an "old" 'Fab pen + pen.addComponent(self.baseGlyph, self.offset, self.scale) + + def drawPoints(self, pen): + """draw the object with a point pen""" + oX, oY = self.offset + sX, sY = self.scale + #xScale, xyScale, yxScale, yScale, xOffset, yOffset + pen.addComponent(self.baseGlyph, (sX, 0, 0, sY, oX, oY)) + + +class BaseAnchor(RBaseObject): + + """Base class for all anchor point objects.""" + + def __init__(self): + RBaseObject.__init__(self) + self.changed = False # if the object needs to be saved + self.selected = False + + def __repr__(self): + font = "unnamed_font" + glyph = "unnamed_glyph" + glyphParent = self.getParent() + if glyphParent is not None: + try: + glyph = glyphParent.name + except AttributeError: pass + fontParent = glyphParent.getParent() + if fontParent is not None: + try: + font = fontParent.info.postscriptFullName + except AttributeError: pass + return "<RAnchor for %s.%s.anchors[%s]>"%(font, glyph, `self.index`) + + def __add__(self, other): + warn("Anchor math has been deprecated and is slated for removal.", DeprecationWarning) + #Add one anchor to another + n = self.copy() + n.x, n.y = addPt((self.x, self.y), (other.x, other.y)) + return n + + def __sub__(self, other): + warn("Anchor math has been deprecated and is slated for removal.", DeprecationWarning) + #Substract one anchor from another + n = self.copy() + n.x, n.y = subPt((self.x, self.y), (other.x, other.y)) + return n + + def __mul__(self, factor): + warn("Anchor math has been deprecated and is slated for removal.", DeprecationWarning) + #Multiply the anchor with factor. Factor can be a tuple of 2 *(f1, f2) + n = self.copy() + n.x, n.y = mulPt((self.x, self.y), factor) + return n + + __rmul__ = __mul__ + + def _hasChanged(self): + #mark the object and it's parent as changed + self.setChanged(True) + if self.getParent() is not None: + self.getParent()._hasChanged() + + def copy(self, aParent=None): + """Duplicate this anchor.""" + n = self.__class__() + if aParent is not None: + n.setParent(aParent) + elif self.getParent() is not None: + n.setParent(self.getParent()) + dont = ['getParent', '_object'] + for k in self.__dict__.keys(): + if k in dont: + continue + elif isinstance(self.__dict__[k], (RBaseObject, BaseLib)): + dup = self.__dict__[k].copy(n) + else: + dup = copy.deepcopy(self.__dict__[k]) + setattr(n, k, dup) + return n + + def round(self): + """round the values in the anchor""" + self.x, self.y = roundPt((self.x, self.y)) + self._hasChanged() + + def draw(self, pen): + """Draw the object onto a segment pen""" + if isinstance(pen, AbstractPen): + # It's a FontTools pen + pen.moveTo((self.x, self.y)) + pen.endPath() + else: + # It's an "old" 'Fab pen + pen.addAnchor(self.name, (self.x, self.y)) + + def drawPoints(self, pen): + """draw the object with a point pen""" + pen.beginPath() + pen.addPoint((self.x, self.y), segmentType="move", smooth=False, name=self.name) + pen.endPath() + + def move(self, pt): + """Move the anchor""" + x, y = pt + pX, pY = self.position + self.position = (pX+x, pY+y) + + def scale(self, pt, center=(0, 0)): + """scale the anchor""" + pos = self.position + self.position = _scalePointFromCenter(pos, pt, center) + + def transform(self, matrix): + """Transform this anchor. Use a Transform matrix + object from fontTools.misc.transform""" + self.x, self.y = matrix.transformPoint((self.x, self.y)) + + +class BaseGuide(RBaseObject): + + """Base class for all guide objects.""" + + def __init__(self): + RBaseObject.__init__(self) + self.changed = False # if the object needs to be saved + self.selected = False + + +class BaseInfo(RBaseObject): + + _baseAttributes = ["_object", "changed", "selected", "getParent"] + _deprecatedAttributes = ufoLib.deprecatedFontInfoAttributesVersion2 + _infoAttributes = ufoLib.fontInfoAttributesVersion2 + # subclasses may define a list of environment + # specific attributes that can be retrieved or set. + _environmentAttributes = [] + # subclasses may define a list of attributes + # that should not follow the standard get/set + # order provided by __setattr__ and __getattr__. + # for these attributes, the environment specific + # set and get methods must handle this value + # without any pre-call validation. + # (yeah. this is because of some FontLab dumbness.) + _environmentOverrides = [] + + def __setattr__(self, attr, value): + # check to see if the attribute has been + # deprecated. if so, warn the caller and + # update the attribute and value. + if attr in self._deprecatedAttributes: + newAttr, newValue = ufoLib.convertFontInfoValueForAttributeFromVersion1ToVersion2(attr, value) + note = "The %s attribute has been deprecated. Use the new %s attribute." % (attr, newAttr) + warn(note, DeprecationWarning) + attr = newAttr + value = newValue + # setting a known attribute + if attr in self._infoAttributes or attr in self._environmentAttributes: + # lightly test the validity of the value + if value is not None: + isValidValue = ufoLib.validateFontInfoVersion2ValueForAttribute(attr, value) + if not isValidValue: + raise RoboFabError("Invalid value (%s) for attribute (%s)." % (repr(value), attr)) + # use the environment specific info attr set + # method if it is defined. + if hasattr(self, "_environmentSetAttr"): + self._environmentSetAttr(attr, value) + # fallback to super + else: + super(BaseInfo, self).__setattr__(attr, value) + # unknown attribute, test to see if it is a python attr + elif attr in self.__dict__ or attr in self._baseAttributes: + super(BaseInfo, self).__setattr__(attr, value) + # raise an attribute error + else: + raise AttributeError("Unknown attribute %s." % attr) + + # subclasses with environment specific attr setting can + # implement this method. __setattr__ will call it if present. + # def _environmentSetAttr(self, attr, value): + # pass + + def __getattr__(self, attr): + if attr in self._environmentOverrides: + return self._environmentGetAttr(attr) + # check to see if the attribute has been + # deprecated. if so, warn the caller and + # flag the value as needing conversion. + needValueConversionTo1 = False + if attr in self._deprecatedAttributes: + oldAttr = attr + oldValue = attr + newAttr, x = ufoLib.convertFontInfoValueForAttributeFromVersion1ToVersion2(attr, None) + note = "The %s attribute has been deprecated. Use the new %s attribute." % (attr, newAttr) + warn(note, DeprecationWarning) + attr = newAttr + needValueConversionTo1 = True + # getting a known attribute + if attr in self._infoAttributes or attr in self._environmentAttributes: + # use the environment specific info attr get + # method if it is defined. + if hasattr(self, "_environmentGetAttr"): + value = self._environmentGetAttr(attr) + # fallback to super + else: + try: + value = super(BaseInfo, self).__getattribute__(attr) + except AttributeError: + return None + if needValueConversionTo1: + oldAttr, value = ufoLib.convertFontInfoValueForAttributeFromVersion2ToVersion1(attr, value) + return value + # raise an attribute error + else: + raise AttributeError("Unknown attribute %s." % attr) + + # subclasses with environment specific attr retrieval can + # implement this method. __getattr__ will call it if present. + # it should return the requested value. + # def _environmentGetAttr(self, attr): + # pass + +class BaseFeatures(RBaseObject): + + def __init__(self): + RBaseObject.__init__(self) + self._text = "" + + def _get_text(self): + return self._text + + def _set_text(self, value): + assert isinstance(value, basestring) + self._text = value + + text = property(_get_text, _set_text, doc="raw feature text.") + + +class BaseGroups(dict): + + """Base class for all RFont.groups objects""" + + def __init__(self): + pass + + def __repr__(self): + font = "unnamed_font" + fontParent = self.getParent() + if fontParent is not None: + try: + font = fontParent.info.postscriptFullName + except AttributeError: pass + return "<RGroups for %s>"%font + + def getParent(self): + """this method will be overwritten with a weakref if there is a parent.""" + pass + + def setParent(self, parent): + import weakref + self.__dict__['getParent'] = weakref.ref(parent) + + def __setitem__(self, key, value): + #override base class to insure proper data is being stored + if not isinstance(key, str): + raise RoboFabError, 'key must be a string' + if not isinstance(value, list): + raise RoboFabError, 'group must be a list' + super(BaseGroups, self).__setitem__(key, value) + + def findGlyph(self, glyphName): + """return a list of all groups contianing glyphName""" + found = [] + for i in self.keys(): + l = self[i] + if glyphName in l: + found.append(i) + return found + + +class BaseLib(dict): + + """Base class for all lib objects""" + + def __init__(self): + pass + + def __repr__(self): + #this is a doozy! + parent = "unknown_parent" + parentObject = self.getParent() + if parentObject is not None: + #do we have a font? + try: + parent = parentObject.info.postscriptFullName + except AttributeError: + #or do we have a glyph? + try: + parent = parentObject.name + #we must be an orphan + except AttributeError: pass + return "<RLib for %s>"%parent + + def getParent(self): + """this method will be overwritten with a weakref if there is a parent.""" + pass + + def setParent(self, parent): + import weakref + self.__dict__['getParent'] = weakref.ref(parent) + + def copy(self, aParent=None): + """Duplicate this lib.""" + n = self.__class__() + if aParent is not None: + n.setParent(aParent) + elif self.getParent() is not None: + n.setParent(self.getParent()) + for k in self.keys(): + n[k] = copy.deepcopy(self[k]) + return n + + +class BaseKerning(RBaseObject): + + """Base class for all kerning objects. Object behaves like a dict but has + some special kerning specific tricks.""" + + def __init__(self, kerningDict=None): + if not kerningDict: + kerningDict = {} + self._kerning = kerningDict + self.changed = False # if the object needs to be saved + + def __repr__(self): + font = "unnamed_font" + fontParent = self.getParent() + if fontParent is not None: + try: + font = fontParent.info.postscriptFullName + except AttributeError: pass + return "<RKerning for %s>"%font + + def __getitem__(self, key): + if isinstance(key, tuple): + pair = key + return self.get(pair) + elif isinstance(key, str): + raise RoboFabError, 'kerning pair must be a tuple: (left, right)' + else: + keys = self.keys() + if key > len(keys): + raise IndexError + keys.sort() + pair = keys[key] + if not self._kerning.has_key(pair): + raise IndexError + else: + return pair + + def __setitem__(self, pair, value): + if not isinstance(pair, tuple): + raise RoboFabError, 'kerning pair must be a tuple: (left, right)' + else: + if len(pair) != 2: + raise RoboFabError, 'kerning pair must be a tuple: (left, right)' + else: + if value == 0: + if self._kerning.get(pair) is not None: + del self._kerning[pair] + else: + self._kerning[pair] = value + self._hasChanged() + + def __len__(self): + return len(self._kerning.keys()) + + def _hasChanged(self): + """mark the object and it's parent as changed""" + self.setChanged(True) + if self.getParent() is not None: + self.getParent()._hasChanged() + + def keys(self): + """return list of kerning pairs""" + return self._kerning.keys() + + def values(self): + """return a list of kerning values""" + return self._kerning.values() + + def items(self): + """return a list of kerning items""" + return self._kerning.items() + + def has_key(self, pair): + return self._kerning.has_key(pair) + + def get(self, pair, default=None): + """get a value. return None if the pair does not exist""" + value = self._kerning.get(pair, default) + return value + + def remove(self, pair): + """remove a kerning pair""" + self[pair] = 0 + + def getAverage(self): + """return average of all kerning pairs""" + if len(self) == 0: + return 0 + value = 0 + for i in self.values(): + value = value + i + return value / float(len(self)) + + def getExtremes(self): + """return the lowest and highest kerning values""" + if len(self) == 0: + return 0 + values = self.values() + values.append(0) + values.sort() + return (values[0], values[-1]) + + def update(self, kerningDict): + """replace kerning data with the data in the given kerningDict""" + for pair in kerningDict.keys(): + self[pair] = kerningDict[pair] + + def clear(self): + """clear all kerning""" + self._kerning = {} + + def add(self, value): + """add value to all kerning pairs""" + for pair in self.keys(): + self[pair] = self[pair] + value + + def scale(self, value): + """scale all kernng pairs by value""" + for pair in self.keys(): + self[pair] = self[pair] * value + + def minimize(self, minimum=10): + """eliminate pairs with value less than minimum""" + for pair in self.keys(): + if abs(self[pair]) < minimum: + self[pair] = 0 + + def eliminate(self, leftGlyphsToEliminate=None, rightGlyphsToEliminate=None, analyzeOnly=False): + """eliminate pairs containing a left glyph that is in the leftGlyphsToEliminate list + or a right glyph that is in the rightGlyphsToELiminate list. + sideGlyphsToEliminate can be a string: 'a' or list: ['a', 'b']. + analyzeOnly will not remove pairs. it will return a count + of all pairs that would be removed.""" + if analyzeOnly: + count = 0 + lgte = leftGlyphsToEliminate + rgte = rightGlyphsToEliminate + if isinstance(lgte, str): + lgte = [lgte] + if isinstance(rgte, str): + rgte = [rgte] + for pair in self.keys(): + left, right = pair + if left in lgte or right in rgte: + if analyzeOnly: + count = count + 1 + else: + self[pair] = 0 + if analyzeOnly: + return count + else: + return None + + def interpolate(self, sourceDictOne, sourceDictTwo, value, clearExisting=True): + """interpolate the kerning between sourceDictOne + and sourceDictTwo. clearExisting will clear existing + kerning first.""" + if isinstance(value, tuple): + # in case the value is a x, y tuple: use the x only. + value = value[0] + if clearExisting: + self.clear() + pairs = set(sourceDictOne.keys()) | set(sourceDictTwo.keys()) + for pair in pairs: + s1 = sourceDictOne.get(pair, 0) + s2 = sourceDictTwo.get(pair, 0) + self[pair] = _interpolate(s1, s2, value) + + def round(self, multiple=10): + """round the kerning pair values to increments of multiple""" + for pair in self.keys(): + value = self[pair] + self[pair] = int(round(value / float(multiple))) * multiple + + def occurrenceCount(self, glyphsToCount): + """return a dict with glyphs as keys and the number of + occurances of that glyph in the kerning pairs as the value + glyphsToCount can be a string: 'a' or list: ['a', 'b']""" + gtc = glyphsToCount + if isinstance(gtc, str): + gtc = [gtc] + gtcDict = {} + for glyph in gtc: + gtcDict[glyph] = 0 + for pair in self.keys(): + left, right = pair + if not gtcDict.get(left): + gtcDict[left] = 0 + if not gtcDict.get(right): + gtcDict[right] = 0 + gtcDict[left] = gtcDict[left] + 1 + gtcDict[right] = gtcDict[right] + 1 + found = {} + for glyphName in gtc: + found[glyphName] = gtcDict[glyphName] + return found + + def getLeft(self, glyphName): + """Return a list of kerns with glyphName as left character.""" + hits = [] + for k, v in self.items(): + if k[0] == glyphName: + hits.append((k, v)) + return hits + + def getRight(self, glyphName): + """Return a list of kerns with glyphName as left character.""" + hits = [] + for k, v in self.items(): + if k[1] == glyphName: + hits.append((k, v)) + return hits + + def combine(self, kerningDicts, overwriteExisting=True): + """combine two or more kerning dictionaries. + overwrite exsisting duplicate pairs if overwriteExisting=True""" + if isinstance(kerningDicts, dict): + kerningDicts = [kerningDicts] + for kd in kerningDicts: + for pair in kd.keys(): + exists = self.has_key(pair) + if exists and overwriteExisting: + self[pair] = kd[pair] + elif not exists: + self[pair] = kd[pair] + + def swapNames(self, swapTable): + """change glyph names in all kerning pairs based on swapTable. + swapTable = {'BeforeName':'AfterName', ...}""" + for pair in self.keys(): + foundInstance = False + left, right = pair + if swapTable.has_key(left): + left = swapTable[left] + foundInstance = True + if swapTable.has_key(right): + right = swapTable[right] + foundInstance = True + if foundInstance: + self[(left, right)] = self[pair] + self[pair] = 0 + + def explodeClasses(self, leftClassDict=None, rightClassDict=None, analyzeOnly=False): + """turn class kerns into real kerning pairs. classes should + be defined in dicts: {'O':['C', 'G', 'Q'], 'H':['B', 'D', 'E', 'F', 'I']}. + analyzeOnly will not remove pairs. it will return a count + of all pairs that would be added""" + if not leftClassDict: + leftClassDict = {} + if not rightClassDict: + rightClassDict = {} + if analyzeOnly: + count = 0 + for pair in self.keys(): + left, right = pair + value = self[pair] + if leftClassDict.get(left) and rightClassDict.get(right): + allLeft = leftClassDict[left] + [left] + allRight = rightClassDict[right] + [right] + for leftSub in allLeft: + for rightSub in allRight: + if analyzeOnly: + count = count + 1 + else: + self[(leftSub, rightSub)] = value + elif leftClassDict.get(left) and not rightClassDict.get(right): + allLeft = leftClassDict[left] + [left] + for leftSub in allLeft: + if analyzeOnly: + count = count + 1 + else: + self[(leftSub, right)] = value + elif rightClassDict.get(right) and not leftClassDict.get(left): + allRight = rightClassDict[right] + [right] + for rightSub in allRight: + if analyzeOnly: + count = count + 1 + else: + self[(left, rightSub)] = value + if analyzeOnly: + return count + else: + return None + + def implodeClasses(self, leftClassDict=None, rightClassDict=None, analyzeOnly=False): + """condense the number of kerning pairs by applying classes. + this will eliminate all pairs containg the classed glyphs leaving + pairs that contain the key glyphs behind. analyzeOnly will not + remove pairs. it will return a count of all pairs that would be removed.""" + if not leftClassDict: + leftClassDict = {} + if not rightClassDict: + rightClassDict = {} + leftImplode = [] + rightImplode = [] + for value in leftClassDict.values(): + leftImplode = leftImplode + value + for value in rightClassDict.values(): + rightImplode = rightImplode + value + analyzed = self.eliminate(leftGlyphsToEliminate=leftImplode, rightGlyphsToEliminate=rightImplode, analyzeOnly=analyzeOnly) + if analyzeOnly: + return analyzed + else: + return None + + def importAFM(self, path, clearExisting=True): + """Import kerning pairs from an AFM file. clearExisting=True will + clear all exising kerning""" + from fontTools.afmLib import AFM + #a nasty hack to fix line ending problems + f = open(path, 'rb') + text = f.read().replace('\r', '\n') + f.close() + f = open(path, 'wb') + f.write(text) + f.close() + #/nasty hack + kerning = AFM(path)._kerning + if clearExisting: + self.clear() + for pair in kerning.keys(): + self[pair] = kerning[pair] + + def asDict(self, returnIntegers=True): + """return the object as a dictionary""" + if not returnIntegers: + return self._kerning + else: + #duplicate the kerning dict so that we aren't destroying it + kerning = {} + for pair in self.keys(): + kerning[pair] = int(round(self[pair])) + return kerning + + def __add__(self, other): + new = self.__class__() + k = set(self.keys()) | set(other.keys()) + for key in k: + new[key] = self.get(key, 0) + other.get(key, 0) + return new + + def __sub__(self, other): + new = self.__class__() + k = set(self.keys()) | set(other.keys()) + for key in k: + new[key] = self.get(key, 0) - other.get(key, 0) + return new + + def __mul__(self, factor): + new = self.__class__() + for name, value in self.items(): + new[name] = value * factor + return new + + __rmul__ = __mul__ + + def __div__(self, factor): + if factor == 0: + raise ZeroDivisionError + return self.__mul__(1.0/factor) + diff --git a/misc/pylib/robofab/objects/objectsFF.py b/misc/pylib/robofab/objects/objectsFF.py new file mode 100644 index 000000000..4ed6aae1e --- /dev/null +++ b/misc/pylib/robofab/objects/objectsFF.py @@ -0,0 +1,1253 @@ + + +__DEBUG__ = True +__version__ = "0.2" + +""" + RoboFab API Objects for FontForge + http://fontforge.sourceforge.net + + FontForge python docs: + http://fontforge.sourceforge.net/python.html + + Note: This is dead. EvB: "objectsFF.py is very dead and should only serve as an example of "dead" + + History + Version zero. May 2007. EvB + Experiment to see how far the API can be made to work. + + 0.1 extended testing and comparisons for attributes. + 0.2 checked into svn. Still quite raw. Lots of print statements and tests at the end. + + Notes + This code is best used with fontforge compiled as a python extension. + + FontForge Python API: + __doc__ + str(object) -> string + + Return a nice string representation of the object. + If the argument is a string, the return value is the same object. + + __file__ + str(object) -> string + + Return a nice string representation of the object. + If the argument is a string, the return value is the same object. + + __name__ + str(object) -> string + + Return a nice string representation of the object. + If the argument is a string, the return value is the same object. + + activeFont + If invoked from the UI, this returns the currently active font. When not in UI this returns None + + activeFontInUI + If invoked from the UI, this returns the currently active font. When not in UI this returns None + + activeGlyph + If invoked from the UI, this returns the currently active glyph (or None) + + ask + Pops up a dialog asking the user a question and providing a set of buttons for the user to reply with + + askChoices + Pops up a dialog asking the user a question and providing a scrolling list for the user to reply with + + askString + Pops up a dialog asking the user a question and providing a textfield for the user to reply with + + contour + fontforge Contour objects + + contouriter + None + + cvt + fontforge cvt objects + + defaultOtherSubrs + Use FontForge's default "othersubrs" functions for Type1 fonts + + font + FontForge Font object + + fontiter + None + + fonts + Returns a tuple of all loaded fonts + + fontsInFile + Returns a tuple containing the names of any fonts in an external file + + getPrefs + Get FontForge preference items + + glyph + FontForge GlyphPen object + + glyphPen + FontForge Glyph object + + hasSpiro + Returns whether this fontforge has access to Raph Levien's spiro package + + hasUserInterface + Returns whether this fontforge session has a user interface (True if it has opened windows) or is just running a script (False) + + hooks + dict() -> new empty dictionary. + dict(mapping) -> new dictionary initialized from a mapping object's + (key, value) pairs. + dict(seq) -> new dictionary initialized as if via: + d = {} + for k, v in seq: + d[k] = v + dict(**kwargs) -> new dictionary initialized with the name=value pairs + in the keyword argument list. For example: dict(one=1, two=2) + + layer + fontforge Layer objects + + layeriter + None + + loadEncodingFile + Load an encoding file into the list of encodings + + loadNamelist + Load a namelist into the list of namelists + + loadNamelistDir + Load a directory of namelist files into the list of namelists + + loadPlugin + Load a FontForge plugin + + loadPluginDir + Load a directory of FontForge plugin files + + loadPrefs + Load FontForge preference items + + logWarning + Adds a non-fatal message to the Warnings window + + open + Opens a font and returns it + + openFilename + Pops up a file picker dialog asking the user for a filename to open + + parseTTInstrs + Takes a string and parses it into a tuple of truetype instruction bytes + + point + fontforge Point objects + + postError + Pops up an error dialog box with the given title and message + + postNotice + Pops up an notice window with the given title and message + + preloadCidmap + Load a cidmap file + + printSetup + Prepare to print a font sample (select default printer or file, page size, etc.) + + private + FontForge private dictionary + + privateiter + None + + readOtherSubrsFile + Read from a file, "othersubrs" functions for Type1 fonts + + registerImportExport + Adds an import/export spline conversion module + + registerMenuItem + Adds a menu item (which runs a python script) to the font or glyph (or both) windows -- in the Tools menu + + saveFilename + Pops up a file picker dialog asking the user for a filename to use for saving + + savePrefs + Save FontForge preference items + + selection + fontforge selection objects + + setPrefs + Set FontForge preference items + + spiroCorner + int(x[, base]) -> integer + + Convert a string or number to an integer, if possible. A floating point + argument will be truncated towards zero (this does not include a string + representation of a floating point number!) When converting a string, use + the optional base. It is an error to supply a base when converting a + non-string. If the argument is outside the integer range a long object + will be returned instead. + + spiroG2 + int(x[, base]) -> integer + + Convert a string or number to an integer, if possible. A floating point + argument will be truncated towards zero (this does not include a string + representation of a floating point number!) When converting a string, use + the optional base. It is an error to supply a base when converting a + non-string. If the argument is outside the integer range a long object + will be returned instead. + + spiroG4 + int(x[, base]) -> integer + + Convert a string or number to an integer, if possible. A floating point + argument will be truncated towards zero (this does not include a string + representation of a floating point number!) When converting a string, use + the optional base. It is an error to supply a base when converting a + non-string. If the argument is outside the integer range a long object + will be returned instead. + + spiroLeft + int(x[, base]) -> integer + + Convert a string or number to an integer, if possible. A floating point + argument will be truncated towards zero (this does not include a string + representation of a floating point number!) When converting a string, use + the optional base. It is an error to supply a base when converting a + non-string. If the argument is outside the integer range a long object + will be returned instead. + + spiroOpen + int(x[, base]) -> integer + + Convert a string or number to an integer, if possible. A floating point + argument will be truncated towards zero (this does not include a string + representation of a floating point number!) When converting a string, use + the optional base. It is an error to supply a base when converting a + non-string. If the argument is outside the integer range a long object + will be returned instead. + + spiroRight + int(x[, base]) -> integer + + Convert a string or number to an integer, if possible. A floating point + argument will be truncated towards zero (this does not include a string + representation of a floating point number!) When converting a string, use + the optional base. It is an error to supply a base when converting a + non-string. If the argument is outside the integer range a long object + will be returned instead. + + unParseTTInstrs + Takes a tuple of truetype instruction bytes and converts to a human readable string + + unicodeFromName + Given a name, look it up in the namelists and find what unicode code point it maps to (returns -1 if not found) + + version + Returns a string containing the current version of FontForge, as 20061116 + + + + +Problems: + XXX: reading glif from UFO: is the contour order changed in some way? + + +ToDo: + - segments ? + + +""" + +import os +from robofab.objects.objectsBase import BaseFont, BaseGlyph, BaseContour, BaseSegment,\ + BasePoint, BaseBPoint, BaseAnchor, BaseGuide, BaseComponent, BaseKerning, BaseInfo, BaseGroups, BaseLib,\ + roundPt, addPt, _box,\ + MOVE, LINE, CORNER, CURVE, QCURVE, OFFCURVE,\ + relativeBCPIn, relativeBCPOut, absoluteBCPIn, absoluteBCPOut + +from robofab.objects.objectsRF import RGlyph as _RGlyph + +import fontforge +import psMat + + +# a list of attributes that are to be copied when copying a glyph. +# this is used by glyph.copy and font.insertGlyph +GLYPH_COPY_ATTRS = [ + "name", + "width", + "unicodes", + "note", + "lib", + ] + + + +def CurrentFont(): + if fontforge.hasUserInterface(): + _font = fontforge.activeFontInUI() + return RFont(_font) + if __DEBUG__: + print "CurrentFont(): fontforge not running with user interface," + return None + +def OpenFont(fontPath): + obj = fontforge.open(fontPath) + if __DEBUG__: + print "OpenFont", fontPath + print "result:", obj + return RFont(obj) + +def NewFont(fontPath=None): + _font = fontforge.font() + if __DEBUG__: + print "NewFont", fontPath + print "result:", _font + return RFont(_font) + + + + +class RFont(BaseFont): + def __init__(self, font=None): + if font is None: + # make a new font + pass + else: + self._object = font + + # ----------------------------------------------------------------- + # + # access + + def keys(self): + """FF implements __iter__ for the font object - better?""" + return [n.glyphname for n in self._object.glyphs()] + + def has_key(self, glyphName): + return glyphName in self + + def _get_info(self): + return RInfo(self._object) + + info = property(_get_info, doc="font info object") + + def __iter__(self): + for glyphName in self.keys(): + yield self.getGlyph(glyphName) + + + # ----------------------------------------------------------------- + # + # file + + def _get_path(self): + return self._object.path + + path = property(_get_path, doc="path of this file") + + def __contains__(self, glyphName): + return glyphName in self.keys() + + def save(self, path=None): + """Save this font as sfd file. + XXX: how to set a sfd path if is none + """ + if path is not None: + # trying to save it somewhere else + _path = path + else: + _path = self.path + if os.path.splitext(_path)[-1] != ".sfd": + _path = os.path.splitext(_path)[0]+".sfd" + if __DEBUG__: + print "RFont.save() to", _path + self._object.save(_path) + + def naked(self): + return self._object + + def close(self): + if __DEBUG__: + print "RFont.close()" + self._object.close() + + + # ----------------------------------------------------------------- + # + # generate + + def dummyGeneratePreHook(self, *args): + print "dummyGeneratePreHook", args + + def dummyGeneratePostHook(self, *args): + print "dummyGeneratePostHook", args + + def generate(self, outputType, path=None): + """ + generate the font. outputType is the type of font to ouput. + --Ouput Types: + 'pctype1' : PC Type 1 font (binary/PFB) + 'pcmm' : PC MultipleMaster font (PFB) + 'pctype1ascii' : PC Type 1 font (ASCII/PFA) + 'pcmmascii' : PC MultipleMaster font (ASCII/PFA) + 'unixascii' : UNIX ASCII font (ASCII/PFA) + 'mactype1' : Mac Type 1 font (generates suitcase and LWFN file) + 'otfcff' : PS OpenType (CFF-based) font (OTF) + 'otfttf' : PC TrueType/TT OpenType font (TTF) + 'macttf' : Mac TrueType font (generates suitcase) + 'macttdfont' : Mac TrueType font (generates suitcase with resources in data fork) + (doc adapted from http://dev.fontlab.net/flpydoc/) + + path can be a directory or a directory file name combo: + path="DirectoryA/DirectoryB" + path="DirectoryA/DirectoryB/MyFontName" + if no path is given, the file will be output in the same directory + as the vfb file. if no file name is given, the filename will be the + vfb file name with the appropriate suffix. + """ + + extensions = { + 'pctype1': 'pfm', + 'otfcff': 'otf', + } + + if __DEBUG__: + print "font.generate", outputType, path + + # set pre and post hooks (necessary?) + temp = getattr(self._object, "temporary") + if temp is None: + self._object.temporary = {} + else: + if type(self._object.temporary)!=dict: + self._object.temporary = {} + self._object.temporary['generateFontPreHook'] = self.dummyGeneratePreHook + self._object.temporary['generateFontPostHook'] = self.dummyGeneratePostHook + + # make a path for the destination + if path is None: + fileName = os.path.splitext(os.path.basename(self.path))[0] + dirName = os.path.dirname(self.path) + extension = extensions.get(outputType) + if extension is not None: + fileName = "%s.%s"%(fileName, extension) + else: + if __DEBUG__: + print "can't generate font in %s format"%outputType + return + path = os.path.join(dirName, fileName) + + # prepare OTF fields + generateFlags = [] + generateFlags.append('opentype') + # generate + self._object.generate(filename=path, flags=generateFlags) + if __DEBUG__: + print "font.generate():", path + return path + + + # ----------------------------------------------------------------- + # + # kerning stuff + + def _get_kerning(self): + kerning = {} + f = self._object + for g in f.glyphs: + for p in g.kerning: + try: + key = (g.name, f[p.key].name) + kerning[key] = p.value + except AttributeError: pass #catch for TT exception + rk = RKerning(kerning) + rk.setParent(self) + return rk + + kerning = property(_get_kerning, doc="a kerning object") + + # ----------------------------------------------------------------- + # + # glyph stuff + + def getGlyph(self, glyphName): + try: + ffGlyph = self._object[glyphName] + except TypeError: + print "font.getGlyph, can't find glyphName, returning new glyph" + return self.newGlyph(glyphName) + glyph = RGlyph(ffGlyph) + glyph.setParent(self) + return glyph + + def newGlyph(self, glyphName, clear=True): + """Make a new glyph + + Notes: not sure how to make a new glyph without an encoded name. + createChar() seems to be intended for that, but when I pass it -1 + for the unicode, it complains that it wants -1. Perhaps a bug? + """ + # is the glyph already there? + glyph = None + if glyphName in self: + if clear: + self._object[glyphName].clear() + return self[glyphName] + else: + # is the glyph in an encodable place: + slot = self._object.findEncodingSlot(glyphName) + if slot == -1: + # not encoded + print "font.newGlyph: unencoded slot", slot, glyphName + glyph = self._object.createChar(-1, glyphName) + else: + glyph = self._object.createMappedChar(glyphName) + glyph = RGlyph(self._object[glyphName]) + glyph.setParent(self) + return glyph + + def removeGlyph(self, glyphName): + self._object.removeGlyph(glyphName) + + + + +class RGlyph(BaseGlyph): + """Fab wrapper for FF Glyph object""" + def __init__(self, ffGlyph=None): + if ffGlyph is None: + raise RoboFabError + self._object = ffGlyph + # XX anchors seem to be supported, but in a different way + # XX so, I will ignore them for now to get something working. + self.anchors = [] + self.lib = {} + + def naked(self): + return self._object + + def setChanged(self): + self._object.changed() + + + # ----------------------------------------------------------------- + # + # attributes + + def _get_name(self): + return self._object.glyphname + def _set_name(self, value): + self._object.glyphname = value + name = property(_get_name, _set_name, doc="name") + + def _get_note(self): + return self._object.comment + def _set_note(self, note): + self._object.comment = note + note = property(_get_note, _set_note, doc="note") + + def _get_width(self): + return self._object.width + def _set_width(self, width): + self._object.width = width + width = property(_get_width, _set_width, doc="width") + + def _get_leftMargin(self): + return self._object.left_side_bearing + def _set_leftMargin(self, leftMargin): + self._object.left_side_bearing = leftMargin + leftMargin = property(_get_leftMargin, _set_leftMargin, doc="leftMargin") + + def _get_rightMargin(self): + return self._object.right_side_bearing + def _set_rightMargin(self, rightMargin): + self._object.right_side_bearing = rightMargin + rightMargin = property(_get_rightMargin, _set_rightMargin, doc="rightMargin") + + def _get_unicodes(self): + return [self._object.unicode] + def _set_unicodes(self, unicodes): + assert len(unicodes)==1 + self._object.unicode = unicodes[0] + unicodes = property(_get_unicodes, _set_unicodes, doc="unicodes") + + def _get_unicode(self): + return self._object.unicode + def _set_unicode(self, unicode): + self._object.unicode = unicode + unicode = property(_get_unicode, _set_unicode, doc="unicode") + + def _get_box(self): + bounds = self._object.boundingBox() + return bounds + box = property(_get_box, doc="the bounding box of the glyph: (xMin, yMin, xMax, yMax)") + + def _get_mark(self): + """color of the glyph box in the font view. This accepts a 6 hex digit number. + + XXX the FL implementation accepts a + """ + import colorsys + r = (self._object.color&0xff0000)>>16 + g = (self._object.color&0xff00)>>8 + g = (self._object.color&0xff)>>4 + return colorsys.rgb_to_hsv( r, g, b)[0] + + def _set_mark(self, markColor=-1): + import colorsys + self._object.color = colorSys.hsv_to_rgb(markColor, 1, 1) + + mark = property(_get_mark, _set_mark, doc="the color of the glyph box in the font view") + + + # ----------------------------------------------------------------- + # + # pen, drawing + + def getPen(self): + return self._object.glyphPen() + + def __getPointPen(self): + """Return a point pen. + + Note: FontForge doesn't support segment pen, so return an adapter. + """ + from robofab.pens.adapterPens import PointToSegmentPen + segmentPen = self._object.glyphPen() + return PointToSegmentPen(segmentPen) + + def getPointPen(self): + from robofab.pens.rfUFOPen import RFUFOPointPen + pen = RFUFOPointPen(self) + #print "getPointPen", pen, pen.__class__, dir(pen) + return pen + + def draw(self, pen): + """draw + + """ + self._object.draw(pen) + pen = None + + def drawPoints(self, pen): + """drawPoints + + Note: FontForge implements glyph.draw, but not glyph.drawPoints. + """ + from robofab.pens.adapterPens import PointToSegmentPen, SegmentToPointPen + adapter = SegmentToPointPen(pen) + self._object.draw(adapter) + pen = None + + def appendGlyph(self, other): + pen = self.getPen() + other.draw(pen) + + # ----------------------------------------------------------------- + # + # glyphmath + + def round(self): + self._object.round() + + def _getMathDestination(self): + from robofab.objects.objectsRF import RGlyph as _RGlyph + return _RGlyph() + + def _mathCopy(self): + # copy self without contour, component and anchor data + glyph = self._getMathDestination() + glyph.name = self.name + glyph.unicodes = list(self.unicodes) + glyph.width = self.width + glyph.note = self.note + glyph.lib = dict(self.lib) + return glyph + + def __mul__(self, factor): + if __DEBUG__: + print "glyphmath mul", factor + return self.copy() *factor + + __rmul__ = __mul__ + + def __sub__(self, other): + if __DEBUG__: + print "glyphmath sub", other, other.__class__ + return self.copy() - other.copy() + + def __add__(self, other): + if __DEBUG__: + print "glyphmath add", other, other.__class__ + return self.copy() + other.copy() + + def getParent(self): + return self + + def copy(self, aParent=None): + """Make a copy of this glyph. + Note: the copy is not a duplicate fontlab glyph, but + a RF RGlyph with the same outlines. The new glyph is + not part of the fontlab font in any way. Use font.appendGlyph(glyph) + to get it in a FontLab glyph again.""" + from robofab.objects.objectsRF import RGlyph as _RGlyph + newGlyph = _RGlyph() + newGlyph.appendGlyph(self) + for attr in GLYPH_COPY_ATTRS: + value = getattr(self, attr) + setattr(newGlyph, attr, value) + parent = self.getParent() + if aParent is not None: + newGlyph.setParent(aParent) + elif self.getParent() is not None: + newGlyph.setParent(self.getParent()) + return newGlyph + + def _get_contours(self): + # find the contour data and wrap it + + """get the contours in this glyph""" + contours = [] + for n in range(len(self._object.foreground)): + item = self._object.foreground[n] + rc = RContour(item, n) + rc.setParent(self) + contours.append(rc) + #print contours + return contours + + contours = property(_get_contours, doc="allow for iteration through glyph.contours") + + # ----------------------------------------------------------------- + # + # transformations + + def move(self, (x, y)): + matrix = psMat.translate((x,y)) + self._object.transform(matrix) + + def scale(self, (x, y), center=(0,0)): + matrix = psMat.scale(x,y) + self._object.transform(matrix) + + def transform(self, matrix): + self._object.transform(matrix) + + def rotate(self, angle, offset=None): + matrix = psMat.rotate(angle) + self._object.transform(matrix) + + def skew(self, angle, offset=None): + matrix = psMat.skew(angle) + self._object.transform(matrix) + + # ----------------------------------------------------------------- + # + # components stuff + + def decompose(self): + self._object.unlinkRef() + + # ----------------------------------------------------------------- + # + # unicode stuff + + def autoUnicodes(self): + if __DEBUG__: + print "objectsFF.RGlyph.autoUnicodes() not implemented yet." + + # ----------------------------------------------------------------- + # + # contour stuff + + def removeOverlap(self): + self._object.removeOverlap() + + def correctDirection(self, trueType=False): + # no option for trueType, really. + self._object.correctDirection() + + def clear(self): + self._object.clear() + + def __getitem__(self, index): + return self.contours[index] + + +class RContour(BaseContour): + def __init__(self, contour, index=None): + self._object = contour + self.index = index + + def _get_points(self): + pts = [] + for pt in self._object: + wpt = RPoint(pt) + wpt.setParent(self) + pts.append(wpt) + return pts + + points = property(_get_points, doc="get contour points") + + def _get_box(self): + return self._object.boundingBox() + + box = property(_get_box, doc="get contour bounding box") + + def __len__(self): + return len(self._object) + + def __getitem__(self, index): + return self.points[index] + + + +class RPoint(BasePoint): + + def __init__(self, pointObject): + self._object = pointObject + + def _get_x(self): + return self._object.x + + def _set_x(self, value): + self._object.x = value + + x = property(_get_x, _set_x, doc="") + + def _get_y(self): + return self._object.y + + def _set_y(self, value): + self._object.y = value + + y = property(_get_y, _set_y, doc="") + + def _get_type(self): + if self._object.on_curve == 0: + return OFFCURVE + + # XXX not always curve + return CURVE + + def _set_type(self, value): + self._type = value + self._hasChanged() + + type = property(_get_type, _set_type, doc="") + + def __repr__(self): + font = "unnamed_font" + glyph = "unnamed_glyph" + contourIndex = "unknown_contour" + contourParent = self.getParent() + if contourParent is not None: + try: + contourIndex = `contourParent.index` + except AttributeError: pass + glyphParent = contourParent.getParent() + if glyphParent is not None: + try: + glyph = glyphParent.name + except AttributeError: pass + fontParent = glyphParent.getParent() + if fontParent is not None: + try: + font = fontParent.info.fullName + except AttributeError: pass + return "<RPoint for %s.%s[%s]>"%(font, glyph, contourIndex) + + +class RInfo(BaseInfo): + def __init__(self, font): + BaseInfo.__init__(self) + self._object = font + + def _get_familyName(self): + return self._object.familyname + def _set_familyName(self, value): + self._object.familyname = value + familyName = property(_get_familyName, _set_familyName, doc="familyname") + + def _get_fondName(self): + return self._object.fondname + def _set_fondName(self, value): + self._object.fondname = value + fondName = property(_get_fondName, _set_fondName, doc="fondname") + + def _get_fontName(self): + return self._object.fontname + def _set_fontName(self, value): + self._object.fontname = value + fontName = property(_get_fontName, _set_fontName, doc="fontname") + + # styleName doesn't have a specific field, FF has a whole sfnt dict. + # implement fullName because a repr depends on it + def _get_fullName(self): + return self._object.fullname + def _set_fullName(self, value): + self._object.fullname = value + fullName = property(_get_fullName, _set_fullName, doc="fullname") + + def _get_unitsPerEm(self): + return self._object.em + def _set_unitsPerEm(self, value): + self._object.em = value + unitsPerEm = property(_get_unitsPerEm, _set_unitsPerEm, doc="unitsPerEm value") + + def _get_ascender(self): + return self._object.ascent + def _set_ascender(self, value): + self._object.ascent = value + ascender = property(_get_ascender, _set_ascender, doc="ascender value") + + def _get_descender(self): + return -self._object.descent + def _set_descender(self, value): + self._object.descent = -value + descender = property(_get_descender, _set_descender, doc="descender value") + + def _get_copyright(self): + return self._object.copyright + def _set_copyright(self, value): + self._object.copyright = value + copyright = property(_get_copyright, _set_copyright, doc="copyright") + + + +class RKerning(BaseKerning): + + """ Object representing the kerning. + This is going to need some thinking about. + """ + + +__all__ = [ 'RFont', 'RGlyph', 'RContour', 'RPoint', 'RInfo', + 'OpenFont', 'CurrentFont', 'NewFont', 'CurrentFont' + ] + + + +if __name__ == "__main__": + import os + from robofab.objects.objectsRF import RFont as _RFont + from sets import Set + + def dumpFontForgeAPI(testFontPath, printModule=False, + printFont=False, printGlyph=False, + printLayer=False, printContour=False, printPoint=False): + def printAPI(item, name): + print + print "-"*80 + print "API of", item + names = dir(item) + names.sort() + print + + if printAPI: + for n in names: + print + print "%s.%s"%(name, n) + try: + print getattr(item, n).__doc__ + except: + print "# error showing", n + # module + if printModule: + print "module file:", fontforge.__file__ + print "version:", fontforge.version() + print "module doc:", fontforge.__doc__ + print "has User Interface:", fontforge.hasUserInterface() + print "has Spiro:", fontforge.hasSpiro() + printAPI(fontforge, "fontforge") + + # font + fontObj = fontforge.open(testFontPath) + if printFont: + printAPI(fontObj, "font") + + # glyph + glyphObj = fontObj["A"] + if printGlyph: + printAPI(glyphObj, "glyph") + + # layer + layerObj = glyphObj.foreground + if printLayer: + printAPI(layerObj, "layer") + + # contour + contourObj = layerObj[0] + if printContour: + printAPI(contourObj, "contour") + + # point + if printPoint: + pointObj = contourObj[0] + printAPI(pointObj, "point") + + + # other objects + penObj = glyphObj.glyphPen() + printAPI(penObj, "glyphPen") + + # use your own paths here. + demoRoot = "/Users/erik/Develop/Mess/FontForge/objectsFF_work/" + UFOPath = os.path.join(demoRoot, "Test.ufo") + SFDPath = os.path.join(demoRoot, "Test_realSFD2.sfd") + + #dumpFontForgeAPI(UFOPath, printPoint=True) + + # should return None + CurrentFont() + + def compareAttr(obj1, obj2, attrName, isMethod=False): + if isMethod: + a = getattr(obj1, attrName)() + b = getattr(obj2, attrName)() + else: + a = getattr(obj1, attrName) + b = getattr(obj2, attrName) + if a == b and a is not None and b is not None: + print "\tattr %s ok"%attrName, a + return True + else: + print "\t?\t%s error:"%attrName, "%s:"%obj1.__class__, a, "%s:"%obj2.__class__, b + return False + + f = OpenFont(UFOPath) + #f = OpenFont(SFDPath) + ref = _RFont(UFOPath) + + if False: + print + print "test font attributes" + compareAttr(f, ref, "path") + + a = Set(f.keys()) + b = Set(ref.keys()) + print "glyphs in ref, not in f", b.difference(a) + print "glyphs in f, not in ref", a.difference(b) + + print "A" in f, "A" in ref + print f.has_key("A"), ref.has_key("A") + + print + print "test font info attributes" + compareAttr(f.info, ref.info, "ascender") + compareAttr(f.info, ref.info, "descender") + compareAttr(f.info, ref.info, "unitsPerEm") + compareAttr(f.info, ref.info, "copyright") + compareAttr(f.info, ref.info, "fullName") + compareAttr(f.info, ref.info, "familyName") + compareAttr(f.info, ref.info, "fondName") + compareAttr(f.info, ref.info, "fontName") + + # crash + f.save() + + otfOutputPath = os.path.join(demoRoot, "test_ouput.otf") + ufoOutputPath = os.path.join(demoRoot, "test_ouput.ufo") + # generate without path, should end up in the source folder + + f['A'].removeOverlap() + f.generate('otfcff') #, otfPath) + f.generate('pctype1') #, otfPath) + + # generate with path. Type is taken from the extension. + f.generate('otfcff', otfOutputPath) #, otfPath) + f.generate(None, ufoOutputPath) #, otfPath) + + featurePath = os.path.join(demoRoot, "testFeatureOutput.fea") + f.naked().generateFeatureFile(featurePath) + + if False: + # new glyphs + # unencoded + print "new glyph: unencoded", f.newGlyph("test_unencoded_glyph") + # encoded + print "new glyph: encoded", f.newGlyph("Adieresis") + # existing + print "new glyph: existing", f.newGlyph("K") + + print + print "test glyph attributes" + compareAttr(f['A'], ref['A'], "width") + compareAttr(f['A'], ref['A'], "unicode") + compareAttr(f['A'], ref['A'], "name") + compareAttr(f['A'], ref['A'], "box") + compareAttr(f['A'], ref['A'], "leftMargin") + compareAttr(f['A'], ref['A'], "rightMargin") + + if False: + print + print "comparing glyph digests" + failed = [] + for n in f.keys(): + g1 = f[n] + #g1.round() + g2 = ref[n] + #g2.round() + d1 = g1._getDigest() + d2 = g2._getDigest() + if d1 != d2: + failed.append(n) + #print "f: ", d1 + #print "ref: ", d2 + print "digest failed for %s"%". ".join(failed) + + g3 = f['A'] *.333 + print g3 + print g3._getDigest() + f.save() + + if False: + print + print "test contour attributes" + compareAttr(f['A'].contours[0], ref['A'].contours[0], "index") + + #for c in f['A'].contours: + # for p in c.points: + # print p, p.type + + # test with a glyph with just 1 contour so we can be sure we're comparing the same thing + compareAttr(f['C'].contours[0], ref['C'].contours[0], "box") + compareAttr(f['C'].contours[0], ref['C'].contours[0], "__len__", isMethod=True) + + ptf = f['C'].contours[0].points[0] + ptref = ref['C'].contours[0].points[0] + print "x, y", (ptf.x, ptf.y) == (ptref.x, ptref.y), (ptref.x, ptref.y) + print 'type', ptf.type, ptref.type + + print "point inside", f['A'].pointInside((50,10)), ref['A'].pointInside((50,10)) + + + print ref.kerning.keys() + + class GlyphLookupWrapper(dict): + """A wrapper for the lookups / subtable data in a FF glyph. + A lot of data is stored there, so it helps to have something to sort things out. + """ + def __init__(self, ffGlyph): + self._object = ffGlyph + self.refresh() + + def __repr__(self): + return "<GlyphLookupWrapper for %s, %d keys>"%(self._object.glyphname, len(self)) + + def refresh(self): + """Pick some of the values apart.""" + lookups = self._object.getPosSub('*') + for t in lookups: + print 'lookup', t + lookupName = t[0] + lookupType = t[1] + if not lookupName in self: + self[lookupName] = [] + self[lookupName].append(t[1:]) + + def getKerning(self): + """Get a regular kerning dict for this glyph""" + d = {} + left = self._object.glyphname + for name in self.keys(): + for item in self[name]: + print 'item', item + if item[0]!="Pair": + continue + #print 'next glyph:', item[1] + #print 'first glyph x Pos:', item[2] + #print 'first glyph y Pos:', item[3] + #print 'first glyph h Adv:', item[4] + #print 'first glyph v Adv:', item[5] + + #print 'second glyph x Pos:', item[6] + #print 'second glyph y Pos:', item[7] + #print 'second glyph h Adv:', item[8] + #print 'second glyph v Adv:', item[9] + right = item[1] + d[(left, right)] = item[4] + return d + + def setKerning(self, kernDict): + """Set the values of a regular kerning dict to the lookups in a FF glyph.""" + for left, right in kernDict.keys(): + if left != self._object.glyphname: + # should we filter the dict before it gets here? + # easier just to filter it here. + continue + + + + # lets try to find the kerning + A = f['A'].naked() + positionTypes = [ "Position", "Pair", "Substitution", "AltSubs", "MultSubs","Ligature"] + print A.getPosSub('*') + #for t in A.getPosSub('*'): + # print 'lookup subtable name:', t[0] + # print 'positioning type:', t[1] + # if t[1]in positionTypes: + # print 'next glyph:', t[2] + # print 'first glyph x Pos:', t[3] + # print 'first glyph y Pos:', t[4] + # print 'first glyph h Adv:', t[5] + # print 'first glyph v Adv:', t[6] + + # print 'second glyph x Pos:', t[7] + # print 'second glyph y Pos:', t[8] + # print 'second glyph h Adv:', t[9] + # print 'second glyph v Adv:', t[10] + + gw = GlyphLookupWrapper(A) + print gw + print gw.keys() + print gw.getKerning() + + name = "'kern' Horizontal Kerning in Latin lookup 0 subtable" + item = (name, 'quoteright', 0, 0, -200, 0, 0, 0, 0, 0) + + A.removePosSub(name) + apply(A.addPosSub, item) + + + print "after", A.getPosSub('*') + + fn = f.naked() + + name = "'kern' Horizontal Kerning in Latin lookup 0" + + + print "before removing stuff", fn.gpos_lookups + print "removing stuff", fn.removeLookup(name) + print "after removing stuff", fn.gpos_lookups + + flags = () + feature_script_lang = (("kern",(("latn",("dflt")),)),) + print fn.addLookup('kern', 'gpos_pair', flags, feature_script_lang) + print fn.addLookupSubtable('kern', 'myKerning') + + + print fn.gpos_lookups + A.addPosSub('myKerning', 'A', 0, 0, -400, 0, 0, 0, 0, 0) + A.addPosSub('myKerning', 'B', 0, 0, 200, 0, 0, 0, 0, 0) + A.addPosSub('myKerning', 'C', 0, 0, 10, 0, 0, 0, 0, 0) + A.addPosSub('myKerning', 'A', 0, 0, 77, 0, 0, 0, 0, 0) + + + gw = GlyphLookupWrapper(A) + print gw + print gw.keys() + print gw.getKerning() + diff --git a/misc/pylib/robofab/objects/objectsFL.py b/misc/pylib/robofab/objects/objectsFL.py new file mode 100755 index 000000000..3b78ddc14 --- /dev/null +++ b/misc/pylib/robofab/objects/objectsFL.py @@ -0,0 +1,3112 @@ +"""UFO implementation for the objects as used by FontLab 4.5 and higher""" + +from FL import * + +from robofab.tools.toolsFL import GlyphIndexTable, NewGlyph +from robofab.objects.objectsBase import BaseFont, BaseGlyph, BaseContour, BaseSegment,\ + BasePoint, BaseBPoint, BaseAnchor, BaseGuide, BaseComponent, BaseKerning, BaseInfo, BaseFeatures, BaseGroups, BaseLib,\ + roundPt, addPt, _box,\ + MOVE, LINE, CORNER, CURVE, QCURVE, OFFCURVE,\ + relativeBCPIn, relativeBCPOut, absoluteBCPIn, absoluteBCPOut,\ + BasePostScriptFontHintValues, postScriptHintDataLibKey, BasePostScriptGlyphHintValues +from robofab.misc import arrayTools +from robofab.pens.flPen import FLPointPen, FLPointContourPen +from robofab import RoboFabError +import os +from robofab.plistlib import Data, Dict, readPlist, writePlist +from StringIO import StringIO +from robofab import ufoLib +from warnings import warn +import datetime +from robofab.tools.fontlabFeatureSplitter import splitFeaturesForFontLab + + +try: + set +except NameError: + from sets import Set as set + +# local encoding +if os.name in ["mac", "posix"]: + LOCAL_ENCODING = "macroman" +else: + LOCAL_ENCODING = "latin-1" + +_IN_UFO_EXPORT = False + +# a list of attributes that are to be copied when copying a glyph. +# this is used by glyph.copy and font.insertGlyph +GLYPH_COPY_ATTRS = [ + "name", + "width", + "unicodes", + "note", + "lib", + ] + +# Generate Types +PC_TYPE1 = 'pctype1' +PC_MM = 'pcmm' +PC_TYPE1_ASCII = 'pctype1ascii' +PC_MM_ASCII = 'pcmmascii' +UNIX_ASCII = 'unixascii' +MAC_TYPE1 = 'mactype1' +OTF_CFF = 'otfcff' +OTF_TT = 'otfttf' +MAC_TT = 'macttf' +MAC_TT_DFONT = 'macttdfont' + +# doc for these functions taken from: http://dev.fontlab.net/flpydoc/ +# internal name (FontLab name, extension) +_flGenerateTypes ={ PC_TYPE1 : (ftTYPE1, 'pfb'), # PC Type 1 font (binary/PFB) + PC_MM : (ftTYPE1_MM, 'mm'), # PC MultipleMaster font (PFB) + PC_TYPE1_ASCII : (ftTYPE1ASCII, 'pfa'), # PC Type 1 font (ASCII/PFA) + PC_MM_ASCII : (ftTYPE1ASCII_MM, 'mm'), # PC MultipleMaster font (ASCII/PFA) + UNIX_ASCII : (ftTYPE1ASCII, 'pfa'), # UNIX ASCII font (ASCII/PFA) + OTF_TT : (ftTRUETYPE, 'ttf'), # PC TrueType/TT OpenType font (TTF) + OTF_CFF : (ftOPENTYPE, 'otf'), # PS OpenType (CFF-based) font (OTF) + MAC_TYPE1 : (ftMACTYPE1, 'suit'), # Mac Type 1 font (generates suitcase and LWFN file, optionally AFM) + MAC_TT : (ftMACTRUETYPE, 'ttf'), # Mac TrueType font (generates suitcase) + MAC_TT_DFONT : (ftMACTRUETYPE_DFONT, 'dfont'), # Mac TrueType font (generates suitcase with resources in data fork) + } + +## FL Hint stuff +# this should not be referenced outside of this module +# since we may be changing the way this works in the future. + + +""" + + FontLab implementation of psHints objects + + Most of the FL methods relating to ps hints return a list of 16 items. + These values are for the 16 corners of a 4 axis multiple master. + The odd thing is that even single masters get these 16 values. + RoboFab doesn't access the MM masters, so by default, the psHints + object only works with the first element. If you want to access the other + values in the list, give a value between 0 and 15 for impliedMasterIndex + when creating the object. + + From the FontLab docs: + http://dev.fontlab.net/flpydoc/ + + blue_fuzz + blue_scale + blue_shift + + blue_values_num(integer) - number of defined blue values + blue_values[integer[integer]] - two-dimentional array of BlueValues + master index is top-level index + + other_blues_num(integer) - number of defined OtherBlues values + other_blues[integer[integer]] - two-dimentional array of OtherBlues + master index is top-level index + + family_blues_num(integer) - number of FamilyBlues records + family_blues[integer[integer]] - two-dimentional array of FamilyBlues + master index is top-level index + + family_other_blues_num(integer) - number of FamilyOtherBlues records + family_other_blues[integer[integer]] - two-dimentional array of FamilyOtherBlues + master index is top-level index + + force_bold[integer] - list of Force Bold values, one for + each master + stem_snap_h_num(integer) + stem_snap_h + stem_snap_v_num(integer) + stem_snap_v + """ + +class PostScriptFontHintValues(BasePostScriptFontHintValues): + """ Wrapper for font-level PostScript hinting information for FontLab. + Blues values, stem values. + """ + def __init__(self, font=None, impliedMasterIndex=0): + self._object = font.naked() + self._masterIndex = impliedMasterIndex + + def copy(self): + from robofab.objects.objectsRF import PostScriptFontHintValues as _PostScriptFontHintValues + return _PostScriptFontHintValues(data=self.asDict()) + + +class PostScriptGlyphHintValues(BasePostScriptGlyphHintValues): + """ Wrapper for glyph-level PostScript hinting information for FontLab. + vStems, hStems. + """ + def __init__(self, glyph=None): + self._object = glyph.naked() + + def copy(self): + from robofab.objects.objectsRF import PostScriptGlyphHintValues as _PostScriptGlyphHintValues + return _PostScriptGlyphHintValues(data=self.asDict()) + + def _hintObjectsToList(self, item): + data = [] + done = [] + for hint in item: + p = (hint.position, hint.width) + if p in done: + continue + data.append(p) + done.append(p) + data.sort() + return data + + def _listToHintObjects(self, item): + hints = [] + done = [] + for pos, width in item: + if (pos, width) in done: + # we don't want to set duplicates + continue + hints.append(Hint(pos, width)) + done.append((pos,width)) + return hints + + def _getVHints(self): + return self._hintObjectsToList(self._object.vhints) + + def _setVHints(self, values): + # 1 = horizontal hints and links, + # 2 = vertical hints and links + # 3 = all hints and links + self._object.RemoveHints(2) + if values is None: + # just clearing it then + return + values.sort() + for hint in self._listToHintObjects(values): + self._object.vhints.append(hint) + + def _getHHints(self): + return self._hintObjectsToList(self._object.hhints) + + def _setHHints(self, values): + # 1 = horizontal hints and links, + # 2 = vertical hints and links + # 3 = all hints and links + self._object.RemoveHints(1) + if values is None: + # just clearing it then + return + values.sort() + for hint in self._listToHintObjects(values): + self._object.hhints.append(hint) + + vHints = property(_getVHints, _setVHints, doc="postscript hints: vertical hint zones") + hHints = property(_getHHints, _setHHints, doc="postscript hints: horizontal hint zones") + + + +def _glyphHintsToDict(glyph): + data = {} + ## + ## horizontal and vertical hints + ## + # glyph.hhints and glyph.vhints returns a list of Hint objects. + # Hint objects have position and width attributes. + data['hHints'] = [] + for index in xrange(len(glyph.hhints)): + hint = glyph.hhints[index] + data['hHints'].append((hint.position, hint.width)) + if not data['hHints']: + del data['hHints'] + data['vHints'] = [] + for index in xrange(len(glyph.vhints)): + hint = glyph.vhints[index] + data['vHints'].append((hint.position, hint.width)) + if not data['vHints']: + del data['vHints'] + ## + ## horizontal and vertical links + ## + # glyph.hlinks and glyph.vlinks returns a list of Link objects. + # Link objects have node1 and node2 attributes. + data['hLinks'] = [] + for index in xrange(len(glyph.hlinks)): + link = glyph.hlinks[index] + d = { 'node1' : link.node1, + 'node2' : link.node2, + } + data['hLinks'].append(d) + if not data['hLinks']: + del data['hLinks'] + data['vLinks'] = [] + for index in xrange(len(glyph.vlinks)): + link = glyph.vlinks[index] + d = { 'node1' : link.node1, + 'node2' : link.node2, + } + data['vLinks'].append(d) + if not data['vLinks']: + del data['vLinks'] + ## + ## replacement table + ## + # glyph.replace_table returns a list of Replace objects. + # Replace objects have type and index attributes. + data['replaceTable'] = [] + for index in xrange(len(glyph.replace_table)): + replace = glyph.replace_table[index] + d = { 'type' : replace.type, + 'index' : replace.index, + } + data['replaceTable'].append(d) + if not data['replaceTable']: + del data['replaceTable'] + # XXX + # need to support glyph.instructions and glyph.hdmx? + # they are not documented very well. + return data + +def _dictHintsToGlyph(glyph, aDict): + # clear existing hints first + # RemoveHints requires an "integer mode" argument + # but it is not documented. from some simple experiments + # i deduced that + # 1 = horizontal hints and links, + # 2 = vertical hints and links + # 3 = all hints and links + glyph.RemoveHints(3) + ## + ## horizontal and vertical hints + ## + if aDict.has_key('hHints'): + for d in aDict['hHints']: + glyph.hhints.append(Hint(d[0], d[1])) + if aDict.has_key('vHints'): + for d in aDict['vHints']: + glyph.vhints.append(Hint(d[0], d[1])) + ## + ## horizontal and vertical links + ## + if aDict.has_key('hLinks'): + for d in aDict['hLinks']: + glyph.hlinks.append(Link(d['node1'], d['node2'])) + if aDict.has_key('vLinks'): + for d in aDict['vLinks']: + glyph.vlinks.append(Link(d['node1'], d['node2'])) + ## + ## replacement table + ## + if aDict.has_key('replaceTable'): + for d in aDict['replaceTable']: + glyph.replace_table.append(Replace(d['type'], d['index'])) + +# FL Node Types +flMOVE = 17 +flLINE = 1 +flCURVE = 35 +flOFFCURVE = 65 +flSHARP = 0 +# I have no idea what the difference between +# "smooth" and "fixed" is, but booth values +# are returned by FL +flSMOOTH = 4096 +flFIXED = 12288 + + +_flToRFSegmentDict = { flMOVE : MOVE, + flLINE : LINE, + flCURVE : CURVE, + flOFFCURVE : OFFCURVE + } + +_rfToFLSegmentDict = {} +for k, v in _flToRFSegmentDict.items(): + _rfToFLSegmentDict[v] = k + +def _flToRFSegmentType(segmentType): + return _flToRFSegmentDict[segmentType] + +def _rfToFLSegmentType(segmentType): + return _rfToFLSegmentDict[segmentType] + +def _scalePointFromCenter((pointX, pointY), (scaleX, scaleY), (centerX, centerY)): + ogCenter = (centerX, centerY) + scaledCenter = (centerX * scaleX, centerY * scaleY) + shiftVal = (scaledCenter[0] - ogCenter[0], scaledCenter[1] - ogCenter[1]) + scaledPointX = (pointX * scaleX) - shiftVal[0] + scaledPointY = (pointY * scaleY) - shiftVal[1] + return (scaledPointX, scaledPointY) + +# Nostalgia code: +def CurrentFont(): + """Return a RoboFab font object for the currently selected font.""" + f = fl.font + if f is not None: + return RFont(fl.font) + return None + +def CurrentGlyph(): + """Return a RoboFab glyph object for the currently selected glyph.""" + currentPath = fl.font.file_name + if fl.glyph is None: + return None + glyphName = fl.glyph.name + currentFont = None + # is this font already loaded as an RFont? + for font in AllFonts(): + # ugh this won't work because AllFonts sees non RFonts as well.... + if font.path == currentPath: + currentFont = font + break + xx = currentFont[glyphName] + #print "objectsFL.CurrentGlyph parent for %d"% id(xx), xx.getParent() + return xx + +def OpenFont(path=None, note=None): + """Open a font from a path.""" + if path == None: + from robofab.interface.all.dialogs import GetFile + path = GetFile(note) + if path: + if path[-4:].lower() in ['.vfb', '.VFB', '.bak', '.BAK']: + f = Font(path) + fl.Add(f) + return RFont(f) + return None + +def NewFont(familyName=None, styleName=None): + """Make a new font""" + from FL import fl, Font + f = Font() + fl.Add(f) + rf = RFont(f) + if familyName is not None: + rf.info.familyName = familyName + if styleName is not None: + rf.info.styleName = styleName + return rf + +def AllFonts(): + """Return a list of all open fonts.""" + fontCount = len(fl) + all = [] + for index in xrange(fontCount): + naked = fl[index] + all.append(RFont(naked)) + return all + + from robofab.world import CurrentGlyph + +def getGlyphFromMask(g): + """Get a Fab glyph object for the data in the mask layer.""" + from robofab.objects.objectsFL import RGlyph as FL_RGlyph + from robofab.objects.objectsRF import RGlyph as RF_RGlyph + n = g.naked() + mask = n.mask + fg = FL_RGlyph(mask) + rf = RF_RGlyph() + pen = rf.getPointPen() + fg.drawPoints(pen) + rf.width = g.width # can we get to the mask glyph width without flipping the UI? + return rf + +def setMaskToGlyph(maskGlyph, targetGlyph, clear=True): + """Set the maskGlyph as a mask layer in targetGlyph. + maskGlyph is a FontLab or RoboFab RGlyph, orphaned or not. + targetGlyph is a FontLab RGLyph. + clear is a bool. False: keep the existing mask data, True: clear the existing mask data. + """ + from robofab.objects.objectsFL import RGlyph as FL_RGlyph + from FL import Glyph as FL_NakedGlyph + flGlyph = FL_NakedGlyph() # new, orphaned FL glyph + wrapped = FL_RGlyph(flGlyph) # rf wrapper for FL glyph + if not clear: + # copy the existing mask data first + existingMask = getGlyphFromMask(targetGlyph) + if existingMask is not None: + pen = FLPointContourPen(existingMask) + existingMask.drawPoints(pen) + pen = FLPointContourPen(wrapped) + maskGlyph.drawPoints(pen) # draw the data + targetGlyph.naked().mask = wrapped .naked() + targetGlyph.update() + +# the lib getter and setter are shared by RFont and RGlyph +def _get_lib(self): + data = self._object.customdata + if data: + f = StringIO(data) + try: + pList = readPlist(f) + except: # XXX ugh, plistlib can raise lots of things + # Anyway, customdata does not contain valid plist data, + # but we don't need to toss it! + pList = {"org.robofab.fontlab.customdata": Data(data)} + else: + pList = {} + # pass it along to the lib object + l = RLib(pList) + l.setParent(self) + return l + +def _set_lib(self, aDict): + l = RLib({}) + l.setParent(self) + l.update(aDict) + + +def _normalizeLineEndings(s): + return s.replace("\r\n", "\n").replace("\r", "\n") + + +class RFont(BaseFont): + """RoboFab UFO wrapper for FL Font object""" + + _title = "FLFont" + + def __init__(self, font=None): + BaseFont.__init__(self) + if font is None: + from FL import fl, Font + # rather than raise an error we could just start a new font. + font = Font() + fl.Add(font) + #raise RoboFabError, "RFont: there's nothing to wrap!?" + self._object = font + self._lib = {} + self._supportHints = True + self.psHints = PostScriptFontHintValues(self) + self.psHints.setParent(self) + + def keys(self): + keys = {} + for glyph in self._object.glyphs: + glyphName = glyph.name + if glyphName in keys: + n = 1 + while ("%s#%s" % (glyphName, n)) in keys: + n += 1 + newGlyphName = "%s#%s" % (glyphName, n) + print "RoboFab encountered a duplicate glyph name, renaming %r to %r" % (glyphName, newGlyphName) + glyphName = newGlyphName + glyph.name = glyphName + keys[glyphName] = None + return keys.keys() + + def has_key(self, glyphName): + glyph = self._object[glyphName] + if glyph is None: + return False + else: + return True + + __contains__ = has_key + + def __setitem__(self, glyphName, glyph): + self._object[glyphName] = glyph.naked() + + def __cmp__(self, other): + if not hasattr(other, '_object'): + return -1 + return self._compare(other) + # if self._object.file_name == other._object.file_name: + # # so, names match. + # # this will falsely identify two distinct "Untitled" + # # let's check some more + # return 0 + # else: + # return -1 + + +# def _get_psHints(self): +# h = PostScriptFontHintValues(self) +# h.setParent(self) +# return h +# +# psHints = property(_get_psHints, doc="font level postscript hint data") + + def _get_info(self): + return RInfo(self._object) + + info = property(_get_info, doc="font info object") + + def _get_features(self): + return RFeatures(self._object) + + features = property(_get_features, doc="features object") + + def _get_kerning(self): + kerning = {} + f = self._object + for g in f.glyphs: + for p in g.kerning: + try: + key = (g.name, f[p.key].name) + kerning[key] = p.value + except AttributeError: pass #catch for TT exception + rk = RKerning(kerning) + rk.setParent(self) + return rk + + kerning = property(_get_kerning, doc="a kerning object") + + def _set_groups(self, aDict): + g = RGroups({}) + g.setParent(self) + g.update(aDict) + + def _get_groups(self): + groups = {} + for i in self._object.classes: + # test to make sure that the class is properly formatted + if i.find(':') == -1: + continue + key = i.split(':')[0] + value = i.split(':')[1].lstrip().split(' ') + groups[key] = value + rg = RGroups(groups) + rg.setParent(self) + return rg + + groups = property(_get_groups, _set_groups, doc="a group object") + + lib = property(_get_lib, _set_lib, doc="font lib object") + + # + # attributes + # + + def _get_fontIndex(self): + # find the index of the font + # by comparing the file_name + # to all open fonts. if the + # font has no file_name, meaning + # it is a new, unsaved font, + # return the index of the first + # font with no file_name. + selfFileName = self._object.file_name + fontCount = len(fl) + for index in xrange(fontCount): + other = fl[index] + if other.file_name == selfFileName: + return index + + fontIndex = property(_get_fontIndex, doc="the fontindex for this font") + + def _get_path(self): + return self._object.file_name + + path = property(_get_path, doc="path to the font") + + def _get_fileName(self): + if self.path is None: + return None + return os.path.split(self.path) + + fileName = property(_get_fileName, doc="the font's file name") + + def _get_selection(self): + # return a list of glyph names for glyphs selected in the font window + l=[] + for i in range(len(self._object.glyphs)): + if fl.Selected(i) == 1: + l.append(self._object[i].name) + return l + + def _set_selection(self, list): + fl.Unselect() + for i in list: + fl.Select(i) + + selection = property(_get_selection, _set_selection, doc="the glyph selection in the font window") + + + def _makeGlyphlist(self): + # To allow iterations through Font.glyphs. Should become really big in fonts with lotsa letters. + gl = [] + for c in self: + gl.append(c) + return gl + + def _get_glyphs(self): + return self._makeGlyphlist() + + glyphs = property(_get_glyphs, doc="A list of all glyphs in the font, to allow iterations through Font.glyphs") + + def update(self): + """Don't forget to update the font when you are done.""" + fl.UpdateFont(self.fontIndex) + + def save(self, path=None): + """Save the font, path is required.""" + if not path: + if not self._object.file_name: + raise RoboFabError, "No destination path specified." + else: + path = self._object.file_name + fl.Save(self.fontIndex, path) + + def close(self, save=False): + """Close the font, saving is optional.""" + if save: + self.save() + else: + self._object.modified = 0 + fl.Close(self.fontIndex) + + def getGlyph(self, glyphName): + # XXX may need to become private + flGlyph = self._object[glyphName] + if flGlyph is not None: + glyph = RGlyph(flGlyph) + glyph.setParent(self) + return glyph + return self.newGlyph(glyphName) + + def newGlyph(self, glyphName, clear=True): + """Make a new glyph.""" + # the old implementation always updated the font. + # that proved to be very slow. so, the updating is + # now left up to the caller where it can be more + # efficiently managed. + g = NewGlyph(self._object, glyphName, clear, updateFont=False) + return RGlyph(g) + + def insertGlyph(self, glyph, name=None): + """Returns a new glyph that has been inserted into the font. + name = another glyphname if you want to insert as with that.""" + from robofab.objects.objectsRF import RFont as _RFont + from robofab.objects.objectsRF import RGlyph as _RGlyph + oldGlyph = glyph + if name is None: + name = oldGlyph.name + # clear the destination glyph if it exists. + if self.has_key(name): + self[name].clear() + # get the parent for the glyph + otherFont = oldGlyph.getParent() + # in some cases we will use the native + # FL method for appending a glyph. + useNative = True + testingNative = True + while testingNative: + # but, maybe it is an orphan glyph. + # in that case we should not use the native method. + if otherFont is None: + useNative = False + testingNative = False + # or maybe the glyph is coming from a NoneLab font + if otherFont is not None: + if isinstance(otherFont, _RFont): + useNative = False + testingNative = False + # but, it could be a copied FL glyph + # which is a NoneLab glyph that + # has a FontLab font as the parent + elif isinstance(otherFont, RFont): + useNative = False + testingNative = False + # or, maybe the glyph is being replaced, in which + # case the native method should not be used + # since FL will destroy any references to the glyph + if self.has_key(name): + useNative = False + testingNative = False + # if the glyph contains components the native + # method should not be used since FL does + # not reference glyphs in components by + # name, but by index (!!!). + if len(oldGlyph.components) != 0: + useNative = False + testingNative = False + testingNative = False + # finally, insert the glyph. + if useNative: + font = self.naked() + otherFont = oldGlyph.getParent().naked() + self.naked().glyphs.append(otherFont[name]) + newGlyph = self.getGlyph(name) + else: + newGlyph = self.newGlyph(name) + newGlyph.appendGlyph(oldGlyph) + for attr in GLYPH_COPY_ATTRS: + if attr == "name": + value = name + else: + value = getattr(oldGlyph, attr) + setattr(newGlyph, attr, value) + if self._supportHints: + # now we need to transfer the hints from + # the old glyph to the new glyph. we'll do this + # via the dict to hint functions. + hintDict = {} + # if the glyph is a NoneLab glyph, then we need + # to extract the ps hints from the lib + if isinstance(oldGlyph, _RGlyph): + hintDict = oldGlyph.lib.get(postScriptHintDataLibKey, {}) + # otherwise we need to extract the hint dict from the glyph + else: + hintDict = _glyphHintsToDict(oldGlyph.naked()) + # now apply the hint data + if hintDict: + _dictHintsToGlyph(newGlyph.naked(), hintDict) + # delete any remaining hint data from the glyph lib + if newGlyph.lib.has_key(postScriptHintDataLibKey): + del newGlyph.lib[postScriptHintDataLibKey] + return newGlyph + + def removeGlyph(self, glyphName): + """remove a glyph from the font""" + index = self._object.FindGlyph(glyphName) + if index != -1: + del self._object.glyphs[index] + + # + # opentype + # + + def getOTClasses(self): + """Return all OpenType classes as a dict. Relies on properly formatted classes.""" + classes = {} + c = self._object.ot_classes + if c is None: + return classes + c = c.replace('\r', '').replace('\n', '').split(';') + for i in c: + if i.find('=') != -1: + value = [] + i = i.replace(' = ', '=') + name = i.split('=')[0] + v = i.split('=')[1].replace('[', '').replace(']', '').split(' ') + #catch double spaces? + for j in v: + if len(j) > 0: + value.append(j) + classes[name] = value + return classes + + def setOTClasses(self, dict): + """Set all OpenType classes.""" + l = [] + for i in dict.keys(): + l.append(''.join([i, ' = [', ' '.join(dict[i]), '];'])) + self._object.ot_classes = '\n'.join(l) + + def getOTClass(self, name): + """Get a specific OpenType class.""" + classes = self.getOTClasses() + return classes[name] + + def setOTClass(self, name, list): + """Set a specific OpenType class.""" + classes = self.getOTClasses() + classes[name] = list + self.setOTClasses(classes) + + def getOTFeatures(self): + """Return all OpenType features as a dict keyed by name. + The value is a string of the text of the feature.""" + features = {} + for i in self._object.features: + v = [] + for j in i.value.replace('\r', '\n').split('\n'): + if j.find(i.tag) == -1: + v.append(j) + features[i.tag] = '\n'.join(v) + return features + + def setOTFeatures(self, dict): + """Set all OpenType features in the font.""" + features= {} + for i in dict.keys(): + f = [] + f.append('feature %s {'%i) + f.append(dict[i]) + f.append('} %s;'%i) + features[i] = '\n'.join(f) + self._object.features.clean() + for i in features.keys(): + self._object.features.append(Feature(i, features[i])) + + def getOTFeature(self, name): + """return a specific OpenType feature.""" + features = self.getOTFeatures() + return features[name] + + def setOTFeature(self, name, text): + """Set a specific OpenType feature.""" + features = self.getOTFeatures() + features[name] = text + self.setOTFeatures(features) + + # + # guides + # + + def getVGuides(self): + """Return a list of wrapped vertical guides in this RFont""" + vguides=[] + for i in range(len(self._object.vguides)): + g = RGuide(self._object.vguides[i], i) + g.setParent(self) + vguides.append(g) + return vguides + + def getHGuides(self): + """Return a list of wrapped horizontal guides in this RFont""" + hguides=[] + for i in range(len(self._object.hguides)): + g = RGuide(self._object.hguides[i], i) + g.setParent(self) + hguides.append(g) + return hguides + + def appendHGuide(self, position, angle=0): + """Append a horizontal guide""" + position = int(round(position)) + angle = int(round(angle)) + g=Guide(position, angle) + self._object.hguides.append(g) + + def appendVGuide(self, position, angle=0): + """Append a horizontal guide""" + position = int(round(position)) + angle = int(round(angle)) + g=Guide(position, angle) + self._object.vguides.append(g) + + def removeHGuide(self, guide): + """Remove a horizontal guide.""" + pos = (guide.position, guide.angle) + for g in self.getHGuides(): + if (g.position, g.angle) == pos: + del self._object.hguides[g.index] + break + + def removeVGuide(self, guide): + """Remove a vertical guide.""" + pos = (guide.position, guide.angle) + for g in self.getVGuides(): + if (g.position, g.angle) == pos: + del self._object.vguides[g.index] + break + + def clearHGuides(self): + """Clear all horizontal guides.""" + self._object.hguides.clean() + + def clearVGuides(self): + """Clear all vertical guides.""" + self._object.vguides.clean() + + + # + # generators + # + + def generate(self, outputType, path=None): + """ + generate the font. outputType is the type of font to ouput. + --Ouput Types: + 'pctype1' : PC Type 1 font (binary/PFB) + 'pcmm' : PC MultipleMaster font (PFB) + 'pctype1ascii' : PC Type 1 font (ASCII/PFA) + 'pcmmascii' : PC MultipleMaster font (ASCII/PFA) + 'unixascii' : UNIX ASCII font (ASCII/PFA) + 'mactype1' : Mac Type 1 font (generates suitcase and LWFN file) + 'otfcff' : PS OpenType (CFF-based) font (OTF) + 'otfttf' : PC TrueType/TT OpenType font (TTF) + 'macttf' : Mac TrueType font (generates suitcase) + 'macttdfont' : Mac TrueType font (generates suitcase with resources in data fork) + (doc adapted from http://dev.fontlab.net/flpydoc/) + + path can be a directory or a directory file name combo: + path="DirectoryA/DirectoryB" + path="DirectoryA/DirectoryB/MyFontName" + if no path is given, the file will be output in the same directory + as the vfb file. if no file name is given, the filename will be the + vfb file name with the appropriate suffix. + """ + outputType = outputType.lower() + if not _flGenerateTypes.has_key(outputType): + raise RoboFabError, "%s output type is not supported"%outputType + flOutputType, suffix = _flGenerateTypes[outputType] + if path is None: + filePath, fileName = os.path.split(self.path) + fileName = fileName.replace('.vfb', '') + else: + if os.path.isdir(path): + filePath = path + fileName = os.path.split(self.path)[1].replace('.vfb', '') + else: + filePath, fileName = os.path.split(path) + if '.' in fileName: + raise RoboFabError, "filename cannot contain periods.", fileName + fileName = '.'.join([fileName, suffix]) + finalPath = os.path.join(filePath, fileName) + if isinstance(finalPath, unicode): + finalPath = finalPath.encode("utf-8") + # generate is (oddly) an application level method + # rather than a font level method. because of this, + # the font must be the current font. so, make it so. + fl.ifont = self.fontIndex + fl.GenerateFont(flOutputType, finalPath) + + def writeUFO(self, path=None, doProgress=False, glyphNameToFileNameFunc=None, + doHints=False, doInfo=True, doKerning=True, doGroups=True, doLib=True, doFeatures=True, glyphs=None, formatVersion=2): + from robofab.interface.all.dialogs import ProgressBar, Message + # special glyph name to file name conversion + if glyphNameToFileNameFunc is None: + glyphNameToFileNameFunc = self.getGlyphNameToFileNameFunc() + if glyphNameToFileNameFunc is None: + from robofab.tools.glyphNameSchemes import glyphNameToShortFileName + glyphNameToFileNameFunc = glyphNameToShortFileName + # get a valid path + if not path: + if self.path is None: + Message("Please save this font first before exporting to UFO...") + return + else: + path = ufoLib.makeUFOPath(self.path) + # get the glyphs to export + if glyphs is None: + glyphs = self.keys() + # if the file exists, check the format version. + # if the format version being written is different + # from the format version of the existing UFO + # and only some files are set to be written + # raise an error. + if os.path.exists(path): + if os.path.exists(os.path.join(path, "metainfo.plist")): + reader = ufoLib.UFOReader(path) + existingFormatVersion = reader.formatVersion + if formatVersion != existingFormatVersion: + if False in [doInfo, doKerning, doGroups, doLib, doFeatures, set(glyphs) == set(self.keys())]: + Message("When overwriting an existing UFO with a different format version all files must be written.") + return + # the lib must be written if format version is 1 + if not doLib and formatVersion == 1: + Message("The lib must be written when exporting format version 1.") + return + # set up the progress bar + nonGlyphCount = [doInfo, doKerning, doGroups, doLib, doFeatures].count(True) + bar = None + if doProgress: + bar = ProgressBar("Exporting UFO", nonGlyphCount + len(glyphs)) + # try writing + try: + writer = ufoLib.UFOWriter(path, formatVersion=formatVersion) + ## We make a shallow copy if lib, since we add some stuff for export + ## that doesn't need to be retained in memory. + fontLib = dict(self.lib) + # write the font info + if doInfo: + global _IN_UFO_EXPORT + _IN_UFO_EXPORT = True + writer.writeInfo(self.info) + _IN_UFO_EXPORT = False + if bar: + bar.tick() + # write the kerning + if doKerning: + writer.writeKerning(self.kerning.asDict()) + if bar: + bar.tick() + # write the groups + if doGroups: + writer.writeGroups(self.groups) + if bar: + bar.tick() + # write the features + if doFeatures: + if formatVersion == 2: + writer.writeFeatures(self.features.text) + else: + self._writeOpenTypeFeaturesToLib(fontLib) + if bar: + bar.tick() + # write the lib + if doLib: + ## Always export the postscript font hint values to the lib in format version 1 + if formatVersion == 1: + d = self.psHints.asDict() + fontLib[postScriptHintDataLibKey] = d + ## Export the glyph order to the lib + glyphOrder = [nakedGlyph.name for nakedGlyph in self.naked().glyphs] + fontLib["public.glyphOrder"] = glyphOrder + ## export the features + if doFeatures and formatVersion == 1: + self._writeOpenTypeFeaturesToLib(fontLib) + if bar: + bar.tick() + writer.writeLib(fontLib) + if bar: + bar.tick() + # write the glyphs + if glyphs: + glyphSet = writer.getGlyphSet(glyphNameToFileNameFunc) + count = nonGlyphCount + for nakedGlyph in self.naked().glyphs: + if nakedGlyph.name not in glyphs: + continue + glyph = RGlyph(nakedGlyph) + if doHints: + hintStuff = _glyphHintsToDict(glyph.naked()) + if hintStuff: + glyph.lib[postScriptHintDataLibKey] = hintStuff + glyphSet.writeGlyph(glyph.name, glyph, glyph.drawPoints) + # remove the hint dict from the lib + if doHints and glyph.lib.has_key(postScriptHintDataLibKey): + del glyph.lib[postScriptHintDataLibKey] + if bar and not count % 10: + bar.tick(count) + count = count + 1 + glyphSet.writeContents() + # only blindly stop if the user says to + except KeyboardInterrupt: + if bar: + bar.close() + bar = None + # kill the bar + if bar: + bar.close() + + def _writeOpenTypeFeaturesToLib(self, fontLib): + # this should only be used for UFO format version 1 + flFont = self.naked() + cls = flFont.ot_classes + if cls is not None: + fontLib["org.robofab.opentype.classes"] = _normalizeLineEndings(cls).rstrip() + "\n" + if flFont.features: + features = {} + order = [] + for feature in flFont.features: + order.append(feature.tag) + features[feature.tag] = _normalizeLineEndings(feature.value).rstrip() + "\n" + fontLib["org.robofab.opentype.features"] = features + fontLib["org.robofab.opentype.featureorder"] = order + + def readUFO(self, path, doProgress=False, + doHints=False, doInfo=True, doKerning=True, doGroups=True, doLib=True, doFeatures=True, glyphs=None): + """read a .ufo into the font""" + from robofab.pens.flPen import FLPointPen + from robofab.interface.all.dialogs import ProgressBar + # start up the reader + reader = ufoLib.UFOReader(path) + glyphSet = reader.getGlyphSet() + # get a list of glyphs that should be imported + if glyphs is None: + glyphs = glyphSet.keys() + # set up the progress bar + nonGlyphCount = [doInfo, doKerning, doGroups, doLib, doFeatures].count(True) + bar = None + if doProgress: + bar = ProgressBar("Importing UFO", nonGlyphCount + len(glyphs)) + # start reading + try: + fontLib = reader.readLib() + # info + if doInfo: + reader.readInfo(self.info) + if bar: + bar.tick() + # glyphs + count = 1 + glyphOrder = self._getGlyphOrderFromLib(fontLib, glyphSet) + for glyphName in glyphOrder: + if glyphName not in glyphs: + continue + glyph = self.newGlyph(glyphName, clear=True) + pen = FLPointPen(glyph.naked()) + glyphSet.readGlyph(glyphName=glyphName, glyphObject=glyph, pointPen=pen) + if doHints: + hintData = glyph.lib.get(postScriptHintDataLibKey) + if hintData: + _dictHintsToGlyph(glyph.naked(), hintData) + # now that the hints have been extracted from the glyph + # there is no reason to keep the location in the lib. + if glyph.lib.has_key(postScriptHintDataLibKey): + del glyph.lib[postScriptHintDataLibKey] + if bar and not count % 10: + bar.tick(count) + count = count + 1 + # features + if doFeatures: + if reader.formatVersion == 1: + self._readOpenTypeFeaturesFromLib(fontLib) + else: + featureText = reader.readFeatures() + self.features.text = featureText + if bar: + bar.tick() + else: + # remove features stored in the lib + self._readOpenTypeFeaturesFromLib(fontLib, setFeatures=False) + # kerning + if doKerning: + self.kerning.clear() + self.kerning.update(reader.readKerning()) + if bar: + bar.tick() + # groups + if doGroups: + self.groups.clear() + self.groups.update(reader.readGroups()) + if bar: + bar.tick() + # hints in format version 1 + if doHints and reader.formatVersion == 1: + self.psHints._loadFromLib(fontLib) + else: + # remove hint data stored in the lib + if fontLib.has_key(postScriptHintDataLibKey): + del fontLib[postScriptHintDataLibKey] + # lib + if doLib: + self.lib.clear() + self.lib.update(fontLib) + if bar: + bar.tick() + # update the font + self.update() + # only blindly stop if the user says to + except KeyboardInterrupt: + bar.close() + bar = None + # kill the bar + if bar: + bar.close() + + def _getGlyphOrderFromLib(self, fontLib, glyphSet): + key = "public.glyphOrder" + glyphOrder = fontLib.get(key) + if glyphOrder is None: + key = "org.robofab.glyphOrder" + glyphOrder = fontLib.get(key) + if glyphOrder is not None: + # no need to keep track if the glyph order in lib once the font is loaded. + del fontLib[key] + glyphNames = [] + done = {} + for glyphName in glyphOrder: + if glyphName in glyphSet: + glyphNames.append(glyphName) + done[glyphName] = 1 + allGlyphNames = glyphSet.keys() + allGlyphNames.sort() + for glyphName in allGlyphNames: + if glyphName not in done: + glyphNames.append(glyphName) + else: + glyphNames = glyphSet.keys() + glyphNames.sort() + return glyphNames + + def _readOpenTypeFeaturesFromLib(self, fontLib, setFeatures=True): + # setFeatures may be False. in this case, this method + # should only clear the data from the lib. + classes = fontLib.get("org.robofab.opentype.classes") + if classes is not None: + del fontLib["org.robofab.opentype.classes"] + if setFeatures: + self.naked().ot_classes = classes + features = fontLib.get("org.robofab.opentype.features") + if features is not None: + order = fontLib.get("org.robofab.opentype.featureorder") + if order is None: + # for UFOs saved without the feature order, do the same as before. + order = features.keys() + order.sort() + else: + del fontLib["org.robofab.opentype.featureorder"] + del fontLib["org.robofab.opentype.features"] + #features = features.items() + orderedFeatures = [] + for tag in order: + oneFeature = features.get(tag) + if oneFeature is not None: + orderedFeatures.append((tag, oneFeature)) + if setFeatures: + self.naked().features.clean() + for tag, src in orderedFeatures: + self.naked().features.append(Feature(tag, src)) + + + +class RGlyph(BaseGlyph): + """RoboFab wrapper for FL Glyph object""" + + _title = "FLGlyph" + + def __init__(self, flGlyph): + #BaseGlyph.__init__(self) + if flGlyph is None: + raise RoboFabError, "RGlyph: there's nothing to wrap!?" + self._object = flGlyph + self._lib = {} + self._contours = None + + def __getitem__(self, index): + return self.contours[index] + + def __delitem__(self, index): + self._object.DeleteContour(index) + self._invalidateContours() + + def __len__(self): + return len(self.contours) + + lib = property(_get_lib, _set_lib, doc="glyph lib object") + + def _invalidateContours(self): + self._contours = None + + def _buildContours(self): + self._contours = [] + for contourIndex in range(self._object.GetContoursNumber()): + c = RContour(contourIndex) + c.setParent(self) + c._buildSegments() + self._contours.append(c) + + # + # attribute handlers + # + + def _get_index(self): + return self._object.parent.FindGlyph(self.name) + + index = property(_get_index, doc="return the index of the glyph in the font") + + def _get_name(self): + return self._object.name + + def _set_name(self, value): + self._object.name = value + + name = property(_get_name, _set_name, doc="name") + + def _get_psName(self): + return self._object.name + + def _set_psName(self, value): + self._object.name = value + + psName = property(_get_psName, _set_psName, doc="name") + + def _get_baseName(self): + return self._object.name.split('.')[0] + + baseName = property(_get_baseName, doc="") + + def _get_unicode(self): + return self._object.unicode + + def _set_unicode(self, value): + self._object.unicode = value + + unicode = property(_get_unicode, _set_unicode, doc="unicode") + + def _get_unicodes(self): + return self._object.unicodes + + def _set_unicodes(self, value): + self._object.unicodes = value + + unicodes = property(_get_unicodes, _set_unicodes, doc="unicodes") + + def _get_width(self): + return self._object.width + + def _set_width(self, value): + value = int(round(value)) + self._object.width = value + + width = property(_get_width, _set_width, doc="the width") + + def _get_box(self): + if not len(self.contours) and not len(self.components): + return (0, 0, 0, 0) + r = self._object.GetBoundingRect() + return (int(round(r.ll.x)), int(round(r.ll.y)), int(round(r.ur.x)), int(round(r.ur.y))) + + box = property(_get_box, doc="box of glyph as a tuple (xMin, yMin, xMax, yMax)") + + def _get_selected(self): + if fl.Selected(self._object.parent.FindGlyph(self._object.name)): + return 1 + else: + return 0 + + def _set_selected(self, value): + fl.Select(self._object.name, value) + + selected = property(_get_selected, _set_selected, doc="Select or deselect the glyph in the font window") + + def _get_mark(self): + return self._object.mark + + def _set_mark(self, value): + self._object.mark = value + + mark = property(_get_mark, _set_mark, doc="mark") + + def _get_note(self): + s = self._object.note + if s is None: + return s + return unicode(s, LOCAL_ENCODING) + + def _set_note(self, value): + if value is None: + value = '' + if type(value) == type(u""): + value = value.encode(LOCAL_ENCODING) + self._object.note = value + + note = property(_get_note, _set_note, doc="note") + + def _get_psHints(self): + # get an object representing the postscript zone information + return PostScriptGlyphHintValues(self) + + psHints = property(_get_psHints, doc="postscript hint data") + + # + # necessary evil + # + + def update(self): + """Don't forget to update the glyph when you are done.""" + fl.UpdateGlyph(self._object.parent.FindGlyph(self._object.name)) + + # + # methods to make RGlyph compatible with FL.Glyph + # ##are these still needed? + # + + def GetBoundingRect(self, masterIndex): + """FL compatibility""" + return self._object.GetBoundingRect(masterIndex) + + def GetMetrics(self, masterIndex): + """FL compatibility""" + return self._object.GetMetrics(masterIndex) + + def SetMetrics(self, value, masterIndex): + """FL compatibility""" + return self._object.SetMetrics(value, masterIndex) + + # + # object builders + # + + def _get_anchors(self): + return self.getAnchors() + + anchors = property(_get_anchors, doc="allow for iteration through glyph.anchors") + + def _get_components(self): + return self.getComponents() + + components = property(_get_components, doc="allow for iteration through glyph.components") + + def _get_contours(self): + if self._contours is None: + self._buildContours() + return self._contours + + contours = property(_get_contours, doc="allow for iteration through glyph.contours") + + def getAnchors(self): + """Return a list of wrapped anchors in this RGlyph.""" + anchors=[] + for i in range(len(self._object.anchors)): + a = RAnchor(self._object.anchors[i], i) + a.setParent(self) + anchors.append(a) + return anchors + + def getComponents(self): + """Return a list of wrapped components in this RGlyph.""" + components=[] + for i in range(len(self._object.components)): + c = RComponent(self._object.components[i], i) + c.setParent(self) + components.append(c) + return components + + def getVGuides(self): + """Return a list of wrapped vertical guides in this RGlyph""" + vguides=[] + for i in range(len(self._object.vguides)): + g = RGuide(self._object.vguides[i], i) + g.setParent(self) + vguides.append(g) + return vguides + + def getHGuides(self): + """Return a list of wrapped horizontal guides in this RGlyph""" + hguides=[] + for i in range(len(self._object.hguides)): + g = RGuide(self._object.hguides[i], i) + g.setParent(self) + hguides.append(g) + return hguides + + # + # tools + # + + def getPointPen(self): + self._invalidateContours() + # Now just don't muck with glyph.contours before you're done drawing... + return FLPointPen(self) + + def appendComponent(self, baseGlyph, offset=(0, 0), scale=(1, 1)): + """Append a component to the glyph. x and y are optional offset values""" + offset = roundPt((offset[0], offset[1])) + p = FLPointPen(self.naked()) + xx, yy = scale + dx, dy = offset + p.addComponent(baseGlyph, (xx, 0, 0, yy, dx, dy)) + + def appendAnchor(self, name, position): + """Append an anchor to the glyph""" + value = roundPt((position[0], position[1])) + anchor = Anchor(name, value[0], value[1]) + self._object.anchors.append(anchor) + + def appendHGuide(self, position, angle=0): + """Append a horizontal guide""" + position = int(round(position)) + g = Guide(position, angle) + self._object.hguides.append(g) + + def appendVGuide(self, position, angle=0): + """Append a horizontal guide""" + position = int(round(position)) + g = Guide(position, angle) + self._object.vguides.append(g) + + def clearContours(self): + self._object.Clear() + self._invalidateContours() + + def clearComponents(self): + """Clear all components.""" + self._object.components.clean() + + def clearAnchors(self): + """Clear all anchors.""" + self._object.anchors.clean() + + def clearHGuides(self): + """Clear all horizontal guides.""" + self._object.hguides.clean() + + def clearVGuides(self): + """Clear all vertical guides.""" + self._object.vguides.clean() + + def removeComponent(self, component): + """Remove a specific component from the glyph. This only works + if the glyph does not have duplicate components in the same location.""" + pos = (component.baseGlyph, component.offset, component.scale) + a = self.getComponents() + found = [] + for i in a: + if (i.baseGlyph, i.offset, i.scale) == pos: + found.append(i) + if len(found) > 1: + raise RoboFabError, 'Found more than one possible component to remove' + elif len(found) == 1: + del self._object.components[found[0].index] + else: + raise RoboFabError, 'Component does not exist' + + def removeContour(self, index): + """remove a specific contour from the glyph""" + self._object.DeleteContour(index) + self._invalidateContours() + + def removeAnchor(self, anchor): + """Remove a specific anchor from the glyph. This only works + if the glyph does not have anchors with duplicate names + in exactly the same location with the same mark.""" + pos = (anchor.name, anchor.position, anchor.mark) + a = self.getAnchors() + found = [] + for i in a: + if (i.name, i.position, i.mark) == pos: + found.append(i) + if len(found) > 1: + raise RoboFabError, 'Found more than one possible anchor to remove' + elif len(found) == 1: + del self._object.anchors[found[0].index] + else: + raise RoboFabError, 'Anchor does not exist' + + def removeHGuide(self, guide): + """Remove a horizontal guide.""" + pos = (guide.position, guide.angle) + for g in self.getHGuides(): + if (g.position, g.angle) == pos: + del self._object.hguides[g.index] + break + + def removeVGuide(self, guide): + """Remove a vertical guide.""" + pos = (guide.position, guide.angle) + for g in self.getVGuides(): + if (g.position, g.angle) == pos: + del self._object.vguides[g.index] + break + + def center(self, padding=None): + """Equalise sidebearings, set to padding if wanted.""" + left = self.leftMargin + right = self.rightMargin + if padding: + e_left = e_right = padding + else: + e_left = (left + right)/2 + e_right = (left + right) - e_left + self.leftMargin= e_left + self.rightMargin= e_right + + def removeOverlap(self): + """Remove overlap""" + self._object.RemoveOverlap() + self._invalidateContours() + + def decompose(self): + """Decompose all components""" + self._object.Decompose() + self._invalidateContours() + + ##broken! + #def removeHints(self): + # """Remove the hints.""" + # self._object.RemoveHints() + + def autoHint(self): + """Automatically generate type 1 hints.""" + self._object.Autohint() + + def move(self, (x, y), contours=True, components=True, anchors=True): + """Move a glyph's items that are flagged as True""" + x, y = roundPt((x, y)) + self._object.Shift(Point(x, y)) + for c in self.getComponents(): + c.move((x, y)) + for a in self.getAnchors(): + a.move((x, y)) + + def clear(self, contours=True, components=True, anchors=True, guides=True, hints=True): + """Clear all items marked as true from the glyph""" + if contours: + self._object.Clear() + self._invalidateContours() + if components: + self._object.components.clean() + if anchors: + self._object.anchors.clean() + if guides: + self._object.hguides.clean() + self._object.vguides.clean() + if hints: + # RemoveHints requires an "integer mode" argument + # but it is not documented. from some simple experiments + # i deduced that + # 1 = horizontal hints and links, + # 2 = vertical hints and links + # 3 = all hints and links + self._object.RemoveHints(3) + + # + # special treatment for GlyphMath support in FontLab + # + + def _getMathDestination(self): + from robofab.objects.objectsRF import RGlyph as _RGlyph + return _RGlyph() + + def copy(self, aParent=None): + """Make a copy of this glyph. + Note: the copy is not a duplicate fontlab glyph, but + a RF RGlyph with the same outlines. The new glyph is + not part of the fontlab font in any way. Use font.appendGlyph(glyph) + to get it in a FontLab glyph again.""" + from robofab.objects.objectsRF import RGlyph as _RGlyph + newGlyph = _RGlyph() + newGlyph.appendGlyph(self) + for attr in GLYPH_COPY_ATTRS: + value = getattr(self, attr) + setattr(newGlyph, attr, value) + # hints + doHints = False + parent = self.getParent() + if parent is not None and parent._supportHints: + hintStuff = _glyphHintsToDict(self.naked()) + if hintStuff: + newGlyph.lib[postScriptHintDataLibKey] = hintStuff + if aParent is not None: + newGlyph.setParent(aParent) + elif self.getParent() is not None: + newGlyph.setParent(self.getParent()) + return newGlyph + + def __mul__(self, factor): + return self.copy() *factor + + __rmul__ = __mul__ + + def __sub__(self, other): + return self.copy() - other.copy() + + def __add__(self, other): + return self.copy() + other.copy() + + + +class RContour(BaseContour): + + """RoboFab wrapper for non FL contour object""" + + _title = "FLContour" + + def __init__(self, index): + self._index = index + self._parentGlyph = None + self.segments = [] + + def __len__(self): + return len(self.points) + + def _buildSegments(self): + ####################### + # Notes about FL node contour structure + ####################### + # for TT curves, FL lists them as seperate nodes: + # [move, off, off, off, line, off, off] + # and, this list is sequential. after the last on curve, + # it is possible (and likely) that there will be more offCurves + # in our segment object, these should be associated with the + # first segment in the contour. + # + # for PS curves, it is a very different scenerio. + # curve nodes contain points: + # [on, off, off] + # and the list is not in sequential order. the first point in + # the list is the on curve and the subsequent points are the off + # curve points leading up to that on curve. + # + # it is very important to remember these structures when trying + # to understand the code below + + self.segments = [] + offList = [] + nodes = self._nakedParent.nodes + for index in range(self._nodeLength): + x = index + self._startNodeIndex + node = nodes[x] + # we do have a loose off curve. deal with it. + if node.type == flOFFCURVE: + offList.append(x) + # we are not dealing with a loose off curve + else: + s = RSegment(x) + s.setParent(self) + # but do we have a collection of loose off curves above? + # if so, apply them to the segment, and clear the list + if len(offList) != 0: + s._looseOffCurve = offList + offList = [] + self.segments.append(s) + # do we have some off curves now that the contour is complete? + if len(offList) != 0: + # ugh. apply them to the first segment + self.segments[0]._looseOffCurve = offList + + def setParent(self, parentGlyph): + self._parentGlyph = parentGlyph + + def getParent(self): + return self._parentGlyph + + def _get__nakedParent(self): + return self._parentGlyph.naked() + + _nakedParent = property(_get__nakedParent, doc="") + + def _get__startNodeIndex(self): + return self._nakedParent.GetContourBegin(self._index) + + _startNodeIndex = property(_get__startNodeIndex, doc="") + + def _get__nodeLength(self): + return self._nakedParent.GetContourLength(self._index) + + _nodeLength = property(_get__nodeLength, doc="") + + def _get__lastNodeIndex(self): + return self._startNodeIndex + self._nodeLength - 1 + + _lastNodeIndex = property(_get__lastNodeIndex, doc="") + + def _previousNodeIndex(self, index): + return (index - 1) % self._nodeLength + + def _nextNodeIndex(self, index): + return (index + 1) % self._nodeLength + + def _getNode(self, index): + return self._nodes[index] + + def _get__nodes(self): + nodes = [] + for node in self._nakedParent.nodes[self._startNodeIndex:self._startNodeIndex+self._nodeLength-1]: + nodes.append(node) + return nodes + + _nodes = property(_get__nodes, doc="") + + def _get_points(self): + points = [] + for segment in self.segments: + for point in segment.points: + points.append(point) + return points + + points = property(_get_points, doc="") + + def _get_bPoints(self): + bPoints = [] + for segment in self.segments: + bp = RBPoint(segment.index) + bp.setParent(self) + bPoints.append(bp) + return bPoints + + bPoints = property(_get_bPoints, doc="") + + def _get_index(self): + return self._index + + def _set_index(self, index): + if index != self._index: + self._nakedParent.ReorderContour(self._index, index) + # reorder and set the _index of the existing RContour objects + # this will be a better solution than reconstructing all the objects + # segment objects will still, sadly, have to be reconstructed + contourList = self.getParent().contours + contourList.insert(index, contourList.pop(self._index)) + for i in range(len(contourList)): + contourList[i]._index = i + contourList[i]._buildSegments() + + + index = property(_get_index, _set_index, doc="the index of the contour") + + def _get_selected(self): + selected = 0 + nodes = self._nodes + for node in nodes: + if node.selected == 1: + selected = 1 + break + return selected + + def _set_selected(self, value): + if value == 1: + self._nakedParent.SelectContour(self._index) + else: + for node in self._nodes: + node.selected = value + + selected = property(_get_selected, _set_selected, doc="selection of the contour: 1-selected or 0-unselected") + + def appendSegment(self, segmentType, points, smooth=False): + segment = self.insertSegment(index=self._nodeLength, segmentType=segmentType, points=points, smooth=smooth) + return segment + + def insertSegment(self, index, segmentType, points, smooth=False): + """insert a seggment into the contour""" + # do a qcurve insertion + if segmentType == QCURVE: + count = 0 + for point in points[:-1]: + newNode = Node(flOFFCURVE, Point(point[0], point[1])) + self._nakedParent.Insert(newNode, self._startNodeIndex + index + count) + count = count + 1 + newNode = Node(flLINE, Point(points[-1][0], points[-1][1])) + self._nakedParent.Insert(newNode, self._startNodeIndex + index +len(points) - 1) + # do a regular insertion + else: + onX, onY = points[-1] + newNode = Node(_rfToFLSegmentType(segmentType), Point(onX, onY)) + # fix the off curves in case the user is inserting a curve + # but is not specifying off curve points + if segmentType == CURVE and len(points) == 1: + pSeg = self._prevSegment(index) + pOn = pSeg.onCurve + newNode.points[1].Assign(Point(pOn.x, pOn.y)) + newNode.points[2].Assign(Point(onX, onY)) + for pointIndex in range(len(points[:-1])): + x, y = points[pointIndex] + newNode.points[1 + pointIndex].Assign(Point(x, y)) + if smooth: + newNode.alignment = flSMOOTH + self._nakedParent.Insert(newNode, self._startNodeIndex + index) + self._buildSegments() + return self.segments[index] + + def removeSegment(self, index): + """remove a segment from the contour""" + segment = self.segments[index] + # we have a qcurve. umph. + if segment.type == QCURVE: + indexList = [segment._nodeIndex] + segment._looseOffCurve + indexList.sort() + indexList.reverse() + parent = self._nakedParent + for nodeIndex in indexList: + parent.DeleteNode(nodeIndex) + # we have a more sane structure to follow + else: + # store some info for later + next = self._nextSegment(index) + nextOffA = None + nextOffB = None + nextType = next.type + if nextType != LINE and nextType != MOVE: + pA = next.offCurve[0] + nextOffA = (pA.x, pA.y) + pB = next.offCurve[-1] + nextOffB = (pB.x, pB.y) + nodeIndex = segment._nodeIndex + self._nakedParent.DeleteNode(nodeIndex) + self._buildSegments() + # now we must override FL guessing about offCurves + next = self._nextSegment(index - 1) + nextType = next.type + if nextType != LINE and nextType != MOVE: + pA = next.offCurve[0] + pB = next.offCurve[-1] + pA.x, pA.y = nextOffA + pB.x, pB.y = nextOffB + + def reverseContour(self): + """reverse contour direction""" + self._nakedParent.ReverseContour(self._index) + self._buildSegments() + + def setStartSegment(self, segmentIndex): + """set the first node on the contour""" + self._nakedParent.SetStartNode(self._startNodeIndex + segmentIndex) + self.getParent()._invalidateContours() + self.getParent()._buildContours() + + def copy(self, aParent=None): + """Copy this object -- result is an ObjectsRF flavored object. + There is no way to make this work using FontLab objects. + Copy is mainly used for glyphmath. + """ + raise RoboFabError, "copy() for objectsFL.RContour is not implemented." + + + +class RSegment(BaseSegment): + + _title = "FLSegment" + + def __init__(self, flNodeIndex): + BaseSegment.__init__(self) + self._nodeIndex = flNodeIndex + self._looseOffCurve = [] #a list of indexes to loose off curve nodes + + def _get__node(self): + glyph = self.getParent()._nakedParent + return glyph.nodes[self._nodeIndex] + + _node = property(_get__node, doc="") + + def _get_qOffCurve(self): + nodes = self.getParent()._nakedParent.nodes + off = [] + for x in self._looseOffCurve: + off.append(nodes[x]) + return off + + _qOffCurve = property(_get_qOffCurve, doc="free floating off curve nodes in the segment") + + def _get_index(self): + contour = self.getParent() + return self._nodeIndex - contour._startNodeIndex + + index = property(_get_index, doc="") + + def _isQCurve(self): + # loose off curves only appear in q curves + if len(self._looseOffCurve) != 0: + return True + return False + + def _get_type(self): + if self._isQCurve(): + return QCURVE + return _flToRFSegmentType(self._node.type) + + def _set_type(self, segmentType): + if self._isQCurve(): + raise RoboFabError, 'qcurve point types cannot be changed' + oldNode = self._node + oldType = oldNode.type + oldPointType = _flToRFSegmentType(oldType) + if oldPointType == MOVE: + raise RoboFabError, '%s point types cannot be changed'%oldPointType + if segmentType == MOVE or segmentType == OFFCURVE: + raise RoboFabError, '%s point types cannot be assigned'%oldPointType + if oldPointType == segmentType: + return + oldNode.type = _rfToFLSegmentType(segmentType) + + type = property(_get_type, _set_type, doc="") + + def _get_smooth(self): + alignment = self._node.alignment + if alignment == flSMOOTH or alignment == flFIXED: + return True + return False + + def _set_smooth(self, value): + if value: + self._node.alignment = flSMOOTH + else: + self._node.alignment = flSHARP + + smooth = property(_get_smooth, _set_smooth, doc="") + + def _get_points(self): + points = [] + node = self._node + # gather the off curves + # + # are we dealing with a qCurve? ugh. + # gather the loose off curves + if self._isQCurve(): + off = self._qOffCurve + x = 0 + for n in off: + p = RPoint(0) + p.setParent(self) + p._qOffIndex = x + points.append(p) + x = x + 1 + # otherwise get the points associated with the node + else: + index = 1 + for point in node.points[1:]: + p = RPoint(index) + p.setParent(self) + points.append(p) + index = index + 1 + # the last point should always be the on curve + p = RPoint(0) + p.setParent(self) + points.append(p) + return points + + points = property(_get_points, doc="") + + def _get_selected(self): + return self._node.selected + + def _set_selected(self, value): + self._node.selected = value + + selected = property(_get_selected, _set_selected, doc="") + + def move(self, (x, y)): + x, y = roundPt((x, y)) + self._node.Shift(Point(x, y)) + if self._isQCurve(): + qOff = self._qOffCurve + for node in qOff: + node.Shift(Point(x, y)) + + def copy(self, aParent=None): + """Copy this object -- result is an ObjectsRF flavored object. + There is no way to make this work using FontLab objects. + Copy is mainly used for glyphmath. + """ + raise RoboFabError, "copy() for objectsFL.RSegment is not implemented." + + + +class RPoint(BasePoint): + + _title = "FLPoint" + + def __init__(self, pointIndex): + #BasePoint.__init__(self) + self._pointIndex = pointIndex + self._qOffIndex = None + + def _get__parentGlyph(self): + return self._parentContour.getParent() + + _parentGlyph = property(_get__parentGlyph, doc="") + + def _get__parentContour(self): + return self._parentSegment.getParent() + + _parentContour = property(_get__parentContour, doc="") + + def _get__parentSegment(self): + return self.getParent() + + _parentSegment = property(_get__parentSegment, doc="") + + def _get__node(self): + if self._qOffIndex is not None: + return self.getParent()._qOffCurve[self._qOffIndex] + return self.getParent()._node + + _node = property(_get__node, doc="") + + def _get__point(self): + return self._node.points[self._pointIndex] + + _point = property(_get__point, doc="") + + def _get_x(self): + return self._point.x + + def _set_x(self, value): + value = int(round(value)) + self._point.x = value + + x = property(_get_x, _set_x, doc="") + + def _get_y(self): + return self._point.y + + def _set_y(self, value): + value = int(round(value)) + self._point.y = value + + y = property(_get_y, _set_y, doc="") + + def _get_type(self): + if self._pointIndex == 0: + # FL store quad contour data as a list of off curves and lines + # (see note in RContour._buildSegments). So, we need to do + # a bit of trickery to return a decent point type. + # if the straight FL node type is off curve, it is a loose + # quad off curve. return that. + tp = _flToRFSegmentType(self._node.type) + if tp == OFFCURVE: + return OFFCURVE + # otherwise we are dealing with an on curve. in this case, + # we attempt to get the parent segment type and return it. + segment = self.getParent() + if segment is not None: + return segment.type + # we must not have a segment, fall back to straight conversion + return tp + return OFFCURVE + + type = property(_get_type, doc="") + + def _set_selected(self, value): + if self._pointIndex == 0: + self._node.selected = value + + def _get_selected(self): + if self._pointIndex == 0: + return self._node.selected + return False + + selected = property(_get_selected, _set_selected, doc="") + + def move(self, (x, y)): + x, y = roundPt((x, y)) + self._point.Shift(Point(x, y)) + + def scale(self, (x, y), center=(0, 0)): + centerX, centerY = roundPt(center) + point = self._point + point.x, point.y = _scalePointFromCenter((point.x, point.y), (x, y), (centerX, centerY)) + + def copy(self, aParent=None): + """Copy this object -- result is an ObjectsRF flavored object. + There is no way to make this work using FontLab objects. + Copy is mainly used for glyphmath. + """ + raise RoboFabError, "copy() for objectsFL.RPoint is not implemented." + + +class RBPoint(BaseBPoint): + + _title = "FLBPoint" + + def __init__(self, segmentIndex): + #BaseBPoint.__init__(self) + self._segmentIndex = segmentIndex + + def _get__parentSegment(self): + return self.getParent().segments[self._segmentIndex] + + _parentSegment = property(_get__parentSegment, doc="") + + def _get_index(self): + return self._segmentIndex + + index = property(_get_index, doc="") + + def _get_selected(self): + return self._parentSegment.selected + + def _set_selected(self, value): + self._parentSegment.selected = value + + selected = property(_get_selected, _set_selected, doc="") + + def copy(self, aParent=None): + """Copy this object -- result is an ObjectsRF flavored object. + There is no way to make this work using FontLab objects. + Copy is mainly used for glyphmath. + """ + raise RoboFabError, "copy() for objectsFL.RBPoint is not implemented." + + +class RComponent(BaseComponent): + + """RoboFab wrapper for FL Component object""" + + _title = "FLComponent" + + def __init__(self, flComponent, index): + BaseComponent.__init__(self) + self._object = flComponent + self._index=index + + def _get_index(self): + return self._index + + index = property(_get_index, doc="index of component") + + def _get_baseGlyph(self): + return self._object.parent.parent[self._object.index].name + + baseGlyph = property(_get_baseGlyph, doc="") + + def _get_offset(self): + return (int(self._object.delta.x), int(self._object.delta.y)) + + def _set_offset(self, value): + value = roundPt((value[0], value[1])) + self._object.delta=Point(value[0], value[1]) + + offset = property(_get_offset, _set_offset, doc="the offset of the component") + + def _get_scale(self): + return (self._object.scale.x, self._object.scale.y) + + def _set_scale(self, (x, y)): + self._object.scale=Point(x, y) + + scale = property(_get_scale, _set_scale, doc="the scale of the component") + + def move(self, (x, y)): + """Move the component""" + x, y = roundPt((x, y)) + self._object.delta=Point(self._object.delta.x+x, self._object.delta.y+y) + + def decompose(self): + """Decompose the component""" + self._object.Paste() + + def copy(self, aParent=None): + """Copy this object -- result is an ObjectsRF flavored object. + There is no way to make this work using FontLab objects. + Copy is mainly used for glyphmath. + """ + raise RoboFabError, "copy() for objectsFL.RComponent is not implemented." + + + +class RAnchor(BaseAnchor): + """RoboFab wrapper for FL Anchor object""" + + _title = "FLAnchor" + + def __init__(self, flAnchor, index): + BaseAnchor.__init__(self) + self._object = flAnchor + self._index = index + + def _get_y(self): + return self._object.y + + def _set_y(self, value): + self._object.y = int(round(value)) + + y = property(_get_y, _set_y, doc="y") + + def _get_x(self): + return self._object.x + + def _set_x(self, value): + self._object.x = int(round(value)) + + x = property(_get_x, _set_x, doc="x") + + def _get_name(self): + return self._object.name + + def _set_name(self, value): + self._object.name = value + + name = property(_get_name, _set_name, doc="name") + + def _get_mark(self): + return self._object.mark + + def _set_mark(self, value): + self._object.mark = value + + mark = property(_get_mark, _set_mark, doc="mark") + + def _get_index(self): + return self._index + + index = property(_get_index, doc="index of the anchor") + + def _get_position(self): + return (self._object.x, self._object.y) + + def _set_position(self, value): + value = roundPt((value[0], value[1])) + self._object.x=value[0] + self._object.y=value[1] + + position = property(_get_position, _set_position, doc="position of the anchor") + + + +class RGuide(BaseGuide): + + """RoboFab wrapper for FL Guide object""" + + _title = "FLGuide" + + def __init__(self, flGuide, index): + BaseGuide.__init__(self) + self._object = flGuide + self._index = index + + def __repr__(self): + # this is a doozy! + parent = "unknown_parent" + parentObject = self.getParent() + if parentObject is not None: + # do we have a font? + try: + parent = parentObject.info.postscriptFullName + except AttributeError: + # or do we have a glyph? + try: + parent = parentObject.name + # we must be an orphan + except AttributeError: pass + return "<Robofab guide wrapper for %s>"%parent + + def _get_position(self): + return self._object.position + + def _set_position(self, value): + self._object.position = value + + position = property(_get_position, _set_position, doc="position") + + def _get_angle(self): + return self._object.angle + + def _set_angle(self, value): + self._object.angle = value + + angle = property(_get_angle, _set_angle, doc="angle") + + def _get_index(self): + return self._index + + index = property(_get_index, doc="index of the guide") + + +class RGroups(BaseGroups): + + """RoboFab wrapper for FL group data""" + + _title = "FLGroups" + + def __init__(self, aDict): + self.update(aDict) + + def __setitem__(self, key, value): + # override baseclass so that data is stored in FL classes + if not isinstance(key, str): + raise RoboFabError, 'key must be a string' + if not isinstance(value, list): + raise RoboFabError, 'group must be a list' + super(RGroups, self).__setitem__(key, value) + self._setFLGroups() + + def __delitem__(self, key): + # override baseclass so that data is stored in FL classes + super(RGroups, self).__delitem__(key) + self._setFLGroups() + + def _setFLGroups(self): + # set the group data into the font. + if self.getParent() is not None: + groups = [] + for i in self.keys(): + value = ' '.join(self[i]) + groups.append(': '.join([i, value])) + groups.sort() + self.getParent().naked().classes = groups + + def update(self, aDict): + # override baseclass so that data is stored in FL classes + super(RGroups, self).update(aDict) + self._setFLGroups() + + def clear(self): + # override baseclass so that data is stored in FL classes + super(RGroups, self).clear() + self._setFLGroups() + + def pop(self, key): + # override baseclass so that data is stored in FL classes + i = super(RGroups, self).pop(key) + self._setFLGroups() + return i + + def popitem(self): + # override baseclass so that data is stored in FL classes + i = super(RGroups, self).popitem() + self._setFLGroups() + return i + + def setdefault(self, key, value=None): + # override baseclass so that data is stored in FL classes + i = super(RGroups, self).setdefault(key, value) + self._setFLGroups() + return i + + +class RKerning(BaseKerning): + + """RoboFab wrapper for FL Kerning data""" + + _title = "FLKerning" + + def __setitem__(self, pair, value): + if not isinstance(pair, tuple): + raise RoboFabError, 'kerning pair must be a tuple: (left, right)' + else: + if len(pair) != 2: + raise RoboFabError, 'kerning pair must be a tuple: (left, right)' + else: + if value == 0: + if self._kerning.get(pair) is not None: + #see note about setting kerning values to 0 below + self._setFLKerning(pair, 0) + del self._kerning[pair] + else: + #self._kerning[pair] = value + self._setFLKerning(pair, value) + + def _setFLKerning(self, pair, value): + # write a pair back into the font + # + # this is fairly speedy, but setting a pair to 0 is roughly + # 2-3 times slower than setting a real value. this is because + # of all the hoops that must be jumped through to keep FL + # from storing kerning pairs with a value of 0. + parentFont = self.getParent().naked() + left = parentFont[pair[0]] + right = parentFont.FindGlyph(pair[1]) + # the left glyph doesn not exist + if left is None: + return + # the right glyph doesn not exist + if right == -1: + return + self._kerning[pair] = value + leftName = pair[0] + value = int(round(value)) + # pairs set to 0 need to be handled carefully. FL will allow + # for pairs to have a value of 0 (!?), so we must catch them + # when they pop up and make sure that the pair is actually + # removed from the font. + if value == 0: + foundPair = False + # if the value is 0, we don't need to construct a pair + # we just need to make sure that the pair is not in the list + pairs = [] + # so, go through all the pairs and add them to a new list + for flPair in left.kerning: + # we have found the pair. flag it. + if flPair.key == right: + foundPair = True + # not the pair. add it to the list. + else: + pairs.append((flPair.key, flPair.value)) + # if we found it, write it back to the glyph. + if foundPair: + left.kerning = [] + for p in pairs: + new = KerningPair(p[0], p[1]) + left.kerning.append(new) + else: + # non-zero pairs are a bit easier to handle + # we just need to look to see if the pair exists + # if so, change the value and stop the loop. + # if not, add a new pair to the glyph + self._kerning[pair] = value + foundPair = False + for flPair in left.kerning: + if flPair.key == right: + flPair.value = value + foundPair = True + break + if not foundPair: + p = KerningPair(right, value) + left.kerning.append(p) + + def update(self, kerningDict): + """replace kerning data with the data in the given kerningDict""" + # override base class here for speed + parentFont = self.getParent().naked() + # add existing data to the new kerning dict is not being replaced + for pair in self.keys(): + if not kerningDict.has_key(pair): + kerningDict[pair] = self._kerning[pair] + # now clear the existing kerning to make sure that + # all the kerning in residing in the glyphs is gone + self.clear() + self._kerning = kerningDict + kDict = {} + # nest the pairs into a dict keyed by the left glyph + # {'A':{'A':-10, 'B':20, ...}, 'B':{...}, ...} + for left, right in kerningDict.keys(): + value = kerningDict[left, right] + if not left in kDict: + kDict[left] = {} + kDict[left][right] = value + for left in kDict.keys(): + leftGlyph = parentFont[left] + if leftGlyph is not None: + for right in kDict[left].keys(): + value = kDict[left][right] + if value != 0: + rightIndex = parentFont.FindGlyph(right) + if rightIndex != -1: + p = KerningPair(rightIndex, value) + leftGlyph.kerning.append(p) + + def clear(self): + """clear all kerning""" + # override base class here for speed + self._kerning = {} + for glyph in self.getParent().naked().glyphs: + glyph.kerning = [] + + def __add__(self, other): + """Math operations on FL Kerning objects return RF Kerning objects + as they need to be orphaned objects and FL can't deal with that.""" + from sets import Set + from robofab.objects.objectsRF import RKerning as _RKerning + new = _RKerning() + k = Set(self.keys()) | Set(other.keys()) + for key in k: + new[key] = self.get(key, 0) + other.get(key, 0) + return new + + def __sub__(self, other): + """Math operations on FL Kerning objects return RF Kerning objects + as they need to be orphaned objects and FL can't deal with that.""" + from sets import Set + from robofab.objects.objectsRF import RKerning as _RKerning + new = _RKerning() + k = Set(self.keys()) | Set(other.keys()) + for key in k: + new[key] = self.get(key, 0) - other.get(key, 0) + return new + + def __mul__(self, factor): + """Math operations on FL Kerning objects return RF Kerning objects + as they need to be orphaned objects and FL can't deal with that.""" + from robofab.objects.objectsRF import RKerning as _RKerning + new = _RKerning() + for name, value in self.items(): + new[name] = value * factor + return new + + __rmul__ = __mul__ + + def __div__(self, factor): + """Math operations on FL Kerning objects return RF Kerning objects + as they need to be orphaned objects and FL can't deal with that.""" + if factor == 0: + raise ZeroDivisionError + return self.__mul__(1.0/factor) + + +class RLib(BaseLib): + + """RoboFab wrapper for FL lib""" + + # XXX: As of FL 4.6 the customdata field in glyph objects is busted. + # storing anything there causes the glyph to become uneditable. + # however, the customdata field in font objects is stable. + + def __init__(self, aDict): + self.update(aDict) + + def __setitem__(self, key, value): + # override baseclass so that data is stored in customdata field + super(RLib, self).__setitem__(key, value) + self._stashLib() + + def __delitem__(self, key): + # override baseclass so that data is stored in customdata field + super(RLib, self).__delitem__(key) + self._stashLib() + + def _stashLib(self): + # write the plist into the customdata field of the FL object + if self.getParent() is None: + return + if not self: + data = None + elif len(self) == 1 and "org.robofab.fontlab.customdata" in self: + data = self["org.robofab.fontlab.customdata"].data + else: + f = StringIO() + writePlist(self, f) + data = f.getvalue() + f.close() + parent = self.getParent() + parent.naked().customdata = data + + def update(self, aDict): + # override baseclass so that data is stored in customdata field + super(RLib, self).update(aDict) + self._stashLib() + + def clear(self): + # override baseclass so that data is stored in customdata field + super(RLib, self).clear() + self._stashLib() + + def pop(self, key): + # override baseclass so that data is stored in customdata field + i = super(RLib, self).pop(key) + self._stashLib() + return i + + def popitem(self): + # override baseclass so that data is stored in customdata field + i = super(RLib, self).popitem() + self._stashLib() + return i + + def setdefault(self, key, value=None): + # override baseclass so that data is stored in customdata field + i = super(RLib, self).setdefault(key, value) + self._stashLib() + return i + + +def _infoMapDict(**kwargs): + default = dict( + nakedAttribute=None, + type=None, + requiresSetNum=False, + masterSpecific=False, + libLocation=None, + specialGetSet=False + ) + default.update(kwargs) + return default + +def _flipDict(d): + f = {} + for k, v in d.items(): + f[v] = k + return f + +_styleMapStyleName_fromFL = { + 64 : "regular", + 1 : "italic", + 32 : "bold", + 33 : "bold italic" +} +_styleMapStyleName_toFL = _flipDict(_styleMapStyleName_fromFL) + +_postscriptWindowsCharacterSet_fromFL = { + 0 : 1, + 1 : 2, + 2 : 3, + 77 : 4, + 128 : 5, + 129 : 6, + 130 : 7, + 134 : 8, + 136 : 9, + 161 : 10, + 162 : 11, + 163 : 12, + 177 : 13, + 178 : 14, + 186 : 15, + 200 : 16, + 204 : 17, + 222 : 18, + 238 : 19, + 255 : 20, +} +_postscriptWindowsCharacterSet_toFL = _flipDict(_postscriptWindowsCharacterSet_fromFL) + +_openTypeOS2Type_toFL = { + 1 : 0x0002, + 2 : 0x0004, + 3 : 0x0008, + 8 : 0x0100, + 9 : 0x0200, +} +_openTypeOS2Type_fromFL = _flipDict(_openTypeOS2Type_toFL) + +_openTypeOS2WidthClass_fromFL = { + "Ultra-condensed" : 1, + "Extra-condensed" : 2, + "Condensed" : 3, + "Semi-condensed" : 4, + "Medium (normal)" : 5, + "Semi-expanded" : 6, + "Expanded" : 7, + "Extra-expanded" : 8, + "Ultra-expanded" : 9, +} +_openTypeOS2WidthClass_toFL = _flipDict(_openTypeOS2WidthClass_fromFL) + +_postscriptHintAttributes = set(( + "postscriptBlueValues", + "postscriptOtherBlues", + "postscriptFamilyBlues", + "postscriptFamilyOtherBlues", + "postscriptStemSnapH", + "postscriptStemSnapV", +)) + + +class RInfo(BaseInfo): + + """RoboFab wrapper for FL Font Info""" + + _title = "FLInfo" + + _ufoToFLAttrMapping = { + "familyName" : _infoMapDict(valueType=str, nakedAttribute="family_name"), + "styleName" : _infoMapDict(valueType=str, nakedAttribute="style_name"), + "styleMapFamilyName" : _infoMapDict(valueType=str, nakedAttribute="menu_name"), + "styleMapStyleName" : _infoMapDict(valueType=str, nakedAttribute="font_style", specialGetSet=True), + "versionMajor" : _infoMapDict(valueType=int, nakedAttribute="version_major"), + "versionMinor" : _infoMapDict(valueType=int, nakedAttribute="version_minor"), + "year" : _infoMapDict(valueType=int, nakedAttribute="year"), + "copyright" : _infoMapDict(valueType=str, nakedAttribute="copyright"), + "trademark" : _infoMapDict(valueType=str, nakedAttribute="trademark"), + "unitsPerEm" : _infoMapDict(valueType=int, nakedAttribute="upm"), + "descender" : _infoMapDict(valueType=int, nakedAttribute="descender", masterSpecific=True), + "xHeight" : _infoMapDict(valueType=int, nakedAttribute="x_height", masterSpecific=True), + "capHeight" : _infoMapDict(valueType=int, nakedAttribute="cap_height", masterSpecific=True), + "ascender" : _infoMapDict(valueType=int, nakedAttribute="ascender", masterSpecific=True), + "italicAngle" : _infoMapDict(valueType=float, nakedAttribute="italic_angle"), + "note" : _infoMapDict(valueType=str, nakedAttribute="note"), + "openTypeHeadCreated" : _infoMapDict(valueType=str, nakedAttribute=None, specialGetSet=True), # i can't figure out the ttinfo.head_creation values + "openTypeHeadLowestRecPPEM" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.head_lowest_rec_ppem"), + "openTypeHeadFlags" : _infoMapDict(valueType="intList", nakedAttribute=None), # There is an attribute (ttinfo.head_flags), but no user interface. + "openTypeHheaAscender" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.hhea_ascender"), + "openTypeHheaDescender" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.hhea_descender"), + "openTypeHheaLineGap" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.hhea_line_gap"), + "openTypeHheaCaretSlopeRise" : _infoMapDict(valueType=int, nakedAttribute=None), + "openTypeHheaCaretSlopeRun" : _infoMapDict(valueType=int, nakedAttribute=None), + "openTypeHheaCaretOffset" : _infoMapDict(valueType=int, nakedAttribute=None), + "openTypeNameDesigner" : _infoMapDict(valueType=str, nakedAttribute="designer"), + "openTypeNameDesignerURL" : _infoMapDict(valueType=str, nakedAttribute="designer_url"), + "openTypeNameManufacturer" : _infoMapDict(valueType=str, nakedAttribute="source"), + "openTypeNameManufacturerURL" : _infoMapDict(valueType=str, nakedAttribute="vendor_url"), + "openTypeNameLicense" : _infoMapDict(valueType=str, nakedAttribute="license"), + "openTypeNameLicenseURL" : _infoMapDict(valueType=str, nakedAttribute="license_url"), + "openTypeNameVersion" : _infoMapDict(valueType=str, nakedAttribute="tt_version"), + "openTypeNameUniqueID" : _infoMapDict(valueType=str, nakedAttribute="tt_u_id"), + "openTypeNameDescription" : _infoMapDict(valueType=str, nakedAttribute="notice"), + "openTypeNamePreferredFamilyName" : _infoMapDict(valueType=str, nakedAttribute="pref_family_name"), + "openTypeNamePreferredSubfamilyName" : _infoMapDict(valueType=str, nakedAttribute="pref_style_name"), + "openTypeNameCompatibleFullName" : _infoMapDict(valueType=str, nakedAttribute="mac_compatible"), + "openTypeNameSampleText" : _infoMapDict(valueType=str, nakedAttribute=None), + "openTypeNameWWSFamilyName" : _infoMapDict(valueType=str, nakedAttribute=None), + "openTypeNameWWSSubfamilyName" : _infoMapDict(valueType=str, nakedAttribute=None), + "openTypeOS2WidthClass" : _infoMapDict(valueType=int, nakedAttribute="width"), + "openTypeOS2WeightClass" : _infoMapDict(valueType=int, nakedAttribute="weight_code", specialGetSet=True), + "openTypeOS2Selection" : _infoMapDict(valueType="intList", nakedAttribute=None), # ttinfo.os2_fs_selection only returns 0 + "openTypeOS2VendorID" : _infoMapDict(valueType=str, nakedAttribute="vendor"), + "openTypeOS2Panose" : _infoMapDict(valueType="intList", nakedAttribute="panose", specialGetSet=True), + "openTypeOS2FamilyClass" : _infoMapDict(valueType="intList", nakedAttribute="ttinfo.os2_s_family_class", specialGetSet=True), + "openTypeOS2UnicodeRanges" : _infoMapDict(valueType="intList", nakedAttribute="unicoderanges"), + "openTypeOS2CodePageRanges" : _infoMapDict(valueType="intList", nakedAttribute="codepages"), + "openTypeOS2TypoAscender" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_s_typo_ascender"), + "openTypeOS2TypoDescender" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_s_typo_descender"), + "openTypeOS2TypoLineGap" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_s_typo_line_gap"), + "openTypeOS2WinAscent" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_us_win_ascent"), + "openTypeOS2WinDescent" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_us_win_descent", specialGetSet=True), + "openTypeOS2Type" : _infoMapDict(valueType="intList", nakedAttribute="ttinfo.os2_fs_type", specialGetSet=True), + "openTypeOS2SubscriptXSize" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_subscript_x_size"), + "openTypeOS2SubscriptYSize" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_subscript_y_size"), + "openTypeOS2SubscriptXOffset" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_subscript_x_offset"), + "openTypeOS2SubscriptYOffset" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_subscript_y_offset"), + "openTypeOS2SuperscriptXSize" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_superscript_x_size"), + "openTypeOS2SuperscriptYSize" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_superscript_y_size"), + "openTypeOS2SuperscriptXOffset" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_superscript_x_offset"), + "openTypeOS2SuperscriptYOffset" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_superscript_y_offset"), + "openTypeOS2StrikeoutSize" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_strikeout_size"), + "openTypeOS2StrikeoutPosition" : _infoMapDict(valueType=int, nakedAttribute="ttinfo.os2_y_strikeout_position"), + "openTypeVheaVertTypoAscender" : _infoMapDict(valueType=int, nakedAttribute=None), + "openTypeVheaVertTypoDescender" : _infoMapDict(valueType=int, nakedAttribute=None), + "openTypeVheaVertTypoLineGap" : _infoMapDict(valueType=int, nakedAttribute=None), + "openTypeVheaCaretSlopeRise" : _infoMapDict(valueType=int, nakedAttribute=None), + "openTypeVheaCaretSlopeRun" : _infoMapDict(valueType=int, nakedAttribute=None), + "openTypeVheaCaretOffset" : _infoMapDict(valueType=int, nakedAttribute=None), + "postscriptFontName" : _infoMapDict(valueType=str, nakedAttribute="font_name"), + "postscriptFullName" : _infoMapDict(valueType=str, nakedAttribute="full_name"), + "postscriptSlantAngle" : _infoMapDict(valueType=float, nakedAttribute="slant_angle"), + "postscriptUniqueID" : _infoMapDict(valueType=int, nakedAttribute="unique_id"), + "postscriptUnderlineThickness" : _infoMapDict(valueType=int, nakedAttribute="underline_thickness"), + "postscriptUnderlinePosition" : _infoMapDict(valueType=int, nakedAttribute="underline_position"), + "postscriptIsFixedPitch" : _infoMapDict(valueType="boolint", nakedAttribute="is_fixed_pitch"), + "postscriptBlueValues" : _infoMapDict(valueType="intList", nakedAttribute="blue_values", masterSpecific=True, requiresSetNum=True), + "postscriptOtherBlues" : _infoMapDict(valueType="intList", nakedAttribute="other_blues", masterSpecific=True, requiresSetNum=True), + "postscriptFamilyBlues" : _infoMapDict(valueType="intList", nakedAttribute="family_blues", masterSpecific=True, requiresSetNum=True), + "postscriptFamilyOtherBlues" : _infoMapDict(valueType="intList", nakedAttribute="family_other_blues", masterSpecific=True, requiresSetNum=True), + "postscriptStemSnapH" : _infoMapDict(valueType="intList", nakedAttribute="stem_snap_h", masterSpecific=True, requiresSetNum=True), + "postscriptStemSnapV" : _infoMapDict(valueType="intList", nakedAttribute="stem_snap_v", masterSpecific=True, requiresSetNum=True), + "postscriptBlueFuzz" : _infoMapDict(valueType=int, nakedAttribute="blue_fuzz", masterSpecific=True), + "postscriptBlueShift" : _infoMapDict(valueType=int, nakedAttribute="blue_shift", masterSpecific=True), + "postscriptBlueScale" : _infoMapDict(valueType=float, nakedAttribute="blue_scale", masterSpecific=True), + "postscriptForceBold" : _infoMapDict(valueType="boolint", nakedAttribute="force_bold", masterSpecific=True), + "postscriptDefaultWidthX" : _infoMapDict(valueType=int, nakedAttribute="default_width", masterSpecific=True), + "postscriptNominalWidthX" : _infoMapDict(valueType=int, nakedAttribute=None), + "postscriptWeightName" : _infoMapDict(valueType=str, nakedAttribute="weight"), + "postscriptDefaultCharacter" : _infoMapDict(valueType=str, nakedAttribute="default_character"), + "postscriptWindowsCharacterSet" : _infoMapDict(valueType=int, nakedAttribute="ms_charset", specialGetSet=True), + "macintoshFONDFamilyID" : _infoMapDict(valueType=int, nakedAttribute="fond_id"), + "macintoshFONDName" : _infoMapDict(valueType=str, nakedAttribute="apple_name"), + } + _environmentOverrides = ["width", "openTypeOS2WidthClass"] # ugh. + + def __init__(self, font): + super(RInfo, self).__init__() + self._object = font + + def _environmentSetAttr(self, attr, value): + # special fontlab workarounds + if attr == "width": + warn("The width attribute has been deprecated. Use the new openTypeOS2WidthClass attribute.", DeprecationWarning) + attr = "openTypeOS2WidthClass" + if attr == "openTypeOS2WidthClass": + if isinstance(value, basestring) and value not in _openTypeOS2WidthClass_toFL: + print "The openTypeOS2WidthClass value \"%s\" cannot be found in the OpenType OS/2 usWidthClass specification. The value will be set into the FontLab file for now." % value + self._object.width = value + else: + self._object.width = _openTypeOS2WidthClass_toFL[value] + return + # get the attribute data + data = self._ufoToFLAttrMapping[attr] + flAttr = data["nakedAttribute"] + valueType = data["valueType"] + masterSpecific = data["masterSpecific"] + requiresSetNum = data["requiresSetNum"] + specialGetSet = data["specialGetSet"] + # warn about setting attributes not supported by FL + if flAttr is None: + print "The attribute %s is not supported by FontLab. This data will not be set." % attr + return + # make sure that the value is the proper type for FL + if valueType == "intList": + value = [int(i) for i in value] + elif valueType == "boolint": + value = int(bool(value)) + elif valueType == str: + if value is None: + value = "" + value = value.encode(LOCAL_ENCODING) + elif valueType == int and not isinstance(value, int): + value = int(round(value)) + elif not isinstance(value, valueType): + value = valueType(value) + # handle postscript hint bug in FL + if attr in _postscriptHintAttributes: + value = self._handlePSHintBug(attr, value) + # handle special cases + if specialGetSet: + attr = "_set_%s" % attr + method = getattr(self, attr) + return method(value) + # set the value + obj = self._object + if len(flAttr.split(".")) > 1: + flAttrList = flAttr.split(".") + for i in flAttrList[:-1]: + obj = getattr(obj, i) + flAttr = flAttrList[-1] + ## set the foo_num attribute if necessary + if requiresSetNum: + numAttr = flAttr + "_num" + setattr(obj, numAttr, len(value)) + ## set master 0 if the data is master specific + if masterSpecific: + subObj = getattr(obj, flAttr) + if valueType == "intList": + for index, v in enumerate(value): + subObj[0][index] = v + else: + subObj[0] = value + ## otherwise use a regular set + else: + setattr(obj, flAttr, value) + + def _environmentGetAttr(self, attr): + # special fontlab workarounds + if attr == "width": + warn("The width attribute has been deprecated. Use the new openTypeOS2WidthClass attribute.", DeprecationWarning) + attr = "openTypeOS2WidthClass" + if attr == "openTypeOS2WidthClass": + value = self._object.width + if value not in _openTypeOS2WidthClass_fromFL: + print "The existing openTypeOS2WidthClass value \"%s\" cannot be found in the OpenType OS/2 usWidthClass specification." % value + return + else: + return _openTypeOS2WidthClass_fromFL[value] + # get the attribute data + data = self._ufoToFLAttrMapping[attr] + flAttr = data["nakedAttribute"] + valueType = data["valueType"] + masterSpecific = data["masterSpecific"] + specialGetSet = data["specialGetSet"] + # warn about setting attributes not supported by FL + if flAttr is None: + if not _IN_UFO_EXPORT: + print "The attribute %s is not supported by FontLab." % attr + return + # handle special cases + if specialGetSet: + attr = "_get_%s" % attr + method = getattr(self, attr) + return method() + # get the value + if len(flAttr.split(".")) > 1: + flAttrList = flAttr.split(".") + obj = self._object + for i in flAttrList: + obj = getattr(obj, i) + value = obj + else: + value = getattr(self._object, flAttr) + # grab the first master value if necessary + if masterSpecific: + value = value[0] + # convert if necessary + if valueType == "intList": + value = [int(i) for i in value] + elif valueType == "boolint": + value = bool(value) + elif valueType == str: + if value is None: + pass + else: + value = unicode(value, LOCAL_ENCODING) + elif not isinstance(value, valueType): + value = valueType(value) + return value + + # ------------------------------ + # individual attribute overrides + # ------------------------------ + + # styleMapStyleName + + def _get_styleMapStyleName(self): + return _styleMapStyleName_fromFL[self._object.font_style] + + def _set_styleMapStyleName(self, value): + value = _styleMapStyleName_toFL[value] + self._object.font_style = value + +# # openTypeHeadCreated +# +# # fontlab epoch: 1969-12-31 19:00:00 +# +# def _get_openTypeHeadCreated(self): +# value = self._object.ttinfo.head_creation +# epoch = datetime.datetime(1969, 12, 31, 19, 0, 0) +# delta = datetime.timedelta(seconds=value[0]) +# t = epoch - delta +# string = "%s-%s-%s %s:%s:%s" % (str(t.year).zfill(4), str(t.month).zfill(2), str(t.day).zfill(2), str(t.hour).zfill(2), str(t.minute).zfill(2), str(t.second).zfill(2)) +# return string +# +# def _set_openTypeHeadCreated(self, value): +# date, time = value.split(" ") +# year, month, day = [int(i) for i in date.split("-")] +# hour, minute, second = [int(i) for i in time.split(":")] +# value = datetime.datetime(year, month, day, hour, minute, second) +# epoch = datetime.datetime(1969, 12, 31, 19, 0, 0) +# delta = epoch - value +# seconds = delta.seconds +# self._object.ttinfo.head_creation[0] = seconds + + # openTypeOS2WeightClass + + def _get_openTypeOS2WeightClass(self): + value = self._object.weight_code + if value == -1: + value = None + return value + + def _set_openTypeOS2WeightClass(self, value): + self._object.weight_code = value + + # openTypeOS2WinDescent + + def _get_openTypeOS2WinDescent(self): + return self._object.ttinfo.os2_us_win_descent + + def _set_openTypeOS2WinDescent(self, value): + if value < 0: + warn("FontLab can only handle positive values for openTypeOS2WinDescent.") + value = abs(value) + self._object.ttinfo.os2_us_win_descent = value + + # openTypeOS2Type + + def _get_openTypeOS2Type(self): + value = self._object.ttinfo.os2_fs_type + intList = [] + for bit, bitNumber in _openTypeOS2Type_fromFL.items(): + if value & bit: + intList.append(bitNumber) + return intList + + def _set_openTypeOS2Type(self, values): + value = 0 + for bitNumber in values: + bit = _openTypeOS2Type_toFL[bitNumber] + value = value | bit + self._object.ttinfo.os2_fs_type = value + + # openTypeOS2Panose + + def _get_openTypeOS2Panose(self): + return [i for i in self._object.panose] + + def _set_openTypeOS2Panose(self, values): + for index, value in enumerate(values): + self._object.panose[index] = value + + # openTypeOS2FamilyClass + + def _get_openTypeOS2FamilyClass(self): + value = self._object.ttinfo.os2_s_family_class + for classID in range(15): + classValue = classID * 256 + if classValue > value: + classID -= 1 + classValue = classID * 256 + break + subclassID = value - classValue + return [classID, subclassID] + + def _set_openTypeOS2FamilyClass(self, values): + classID, subclassID = values + classID = classID * 256 + value = classID + subclassID + self._object.ttinfo.os2_s_family_class = value + + # postscriptWindowsCharacterSet + + def _get_postscriptWindowsCharacterSet(self): + value = self._object.ms_charset + value = _postscriptWindowsCharacterSet_fromFL[value] + return value + + def _set_postscriptWindowsCharacterSet(self, value): + value = _postscriptWindowsCharacterSet_toFL[value] + self._object.ms_charset = value + + # ----------------- + # FL bug workaround + # ----------------- + + def _handlePSHintBug(self, attribute, values): + """Function to handle problems with FontLab not allowing the max number of + alignment zones to be set to the max number. + Input: the name of the zones and the values to be set + Output: a warning when there are too many values to be set + and the max values which FontLab will allow. + """ + originalValues = values + truncatedLength = None + if attribute in ("postscriptStemSnapH", "postscriptStemSnapV"): + if len(values) > 10: + values = values[:10] + truncatedLength = 10 + elif attribute in ("postscriptBlueValues", "postscriptFamilyBlues"): + if len(values) > 12: + values = values[:12] + truncatedLength = 12 + elif attribute in ("postscriptOtherBlues", "postscriptFamilyOtherBlues"): + if len(values) > 8: + values = values[:8] + truncatedLength = 8 + if truncatedLength is not None: + print "* * * WARNING: FontLab will only accept %d %s items maximum from Python. Dropping values: %s." % (truncatedLength, attribute, str(originalValues[truncatedLength:])) + return values + + +class RFeatures(BaseFeatures): + + _title = "FLFeatures" + + def __init__(self, font): + super(RFeatures, self).__init__() + self._object = font + + def _get_text(self): + naked = self._object + features = [] + if naked.ot_classes: + features.append(_normalizeLineEndings(naked.ot_classes)) + for feature in naked.features: + features.append(_normalizeLineEndings(feature.value)) + return "".join(features) + + def _set_text(self, value): + classes, features = splitFeaturesForFontLab(value) + naked = self._object + naked.ot_classes = classes + naked.features.clean() + for featureName, featureText in features: + f = Feature(featureName, featureText) + naked.features.append(f) + + text = property(_get_text, _set_text, doc="raw feature text.") + diff --git a/misc/pylib/robofab/objects/objectsRF.pyx b/misc/pylib/robofab/objects/objectsRF.pyx new file mode 100755 index 000000000..50e1f13a7 --- /dev/null +++ b/misc/pylib/robofab/objects/objectsRF.pyx @@ -0,0 +1,1233 @@ +"""UFO for GlifLib""" + +from robofab import RoboFabError, RoboFabWarning +from robofab.objects.objectsBase import BaseFont, BaseKerning, BaseGroups, BaseInfo, BaseFeatures, BaseLib,\ + BaseGlyph, BaseContour, BaseSegment, BasePoint, BaseBPoint, BaseAnchor, BaseGuide, BaseComponent, \ + relativeBCPIn, relativeBCPOut, absoluteBCPIn, absoluteBCPOut, _box,\ + _interpolate, _interpolatePt, roundPt, addPt,\ + MOVE, LINE, CORNER, CURVE, QCURVE, OFFCURVE,\ + BasePostScriptFontHintValues, postScriptHintDataLibKey, BasePostScriptGlyphHintValues + +import os + + +__all__ = [ "CurrentFont", + "CurrentGlyph", 'OpenFont', + 'RFont', 'RGlyph', 'RContour', + 'RPoint', 'RBPoint', 'RAnchor', + 'RComponent' + ] + + + +def CurrentFont(): + return None + +def CurrentGlyph(): + return None + +def OpenFont(path=None, note=None): + """Open a font from a path. If path is not given, present the user with a dialog.""" + if not note: + note = 'select a .ufo directory' + if not path: + from robofab.interface.all.dialogs import GetFolder + path = GetFolder(note) + if path: + try: + return RFont(path) + except OSError: + from robofab.interface.all.dialogs import Message + Message("%s is not a valid .UFO font. But considering it's all XML, why don't you have a look inside with a simple text editor."%(path)) + else: + return None + +def NewFont(familyName=None, styleName=None): + """Make a new font""" + new = RFont() + if familyName is not None: + new.info.familyName = familyName + if styleName is not None: + new.info.styleName = styleName + return new + +def AllFonts(): + """AllFonts can't work in plain python usage. It's really up to some sort of application + to keep track of which fonts are open.""" + raise NotImplementedError + + +class PostScriptFontHintValues(BasePostScriptFontHintValues): + """ Font level PostScript hints object for objectsRF usage. + If there are values in the lib, use those. + If there are no values in the lib, use defaults. + + The psHints attribute for objectsRF.RFont is basically just the + data read from the Lib. When the object saves to UFO, the + hints are written back to the lib, which is then saved. + + """ + + def __init__(self, aFont=None, data=None): + self.setParent(aFont) + BasePostScriptFontHintValues.__init__(self) + if aFont is not None: + # in version 1, this data was stored in the lib + # if it is still there, guess that it is correct + # move it to font info and remove it from the lib. + libData = aFont.lib.get(postScriptHintDataLibKey) + if libData is not None: + self.fromDict(libData) + del libData[postScriptHintDataLibKey] + if data is not None: + self.fromDict(data) + +def getPostScriptHintDataFromLib(aFont, fontLib): + hintData = fontLib.get(postScriptHintDataLibKey) + psh = PostScriptFontHintValues(aFont) + psh.fromDict(hintData) + return psh + +class PostScriptGlyphHintValues(BasePostScriptGlyphHintValues): + """ Glyph level PostScript hints object for objectsRF usage. + If there are values in the lib, use those. + If there are no values in the lib, be empty. + + """ + def __init__(self, aGlyph=None, data=None): + # read the data from the glyph.lib, it won't be anywhere else + BasePostScriptGlyphHintValues.__init__(self) + if aGlyph is not None: + self.setParent(aGlyph) + self._loadFromLib(aGlyph.lib) + if data is not None: + self.fromDict(data) + + +class RFont(BaseFont): + """UFO font object which reads and writes glif, and keeps the data in memory in between. + Bahviour: + - comparable to Font + - comparable to GlyphSet so that it can be passed to Glif widgets + """ + + _title = "RoboFabFont" + + def __init__(self, path=None): + BaseFont.__init__(self) + if path is not None: + self._path = os.path.normpath(os.path.abspath(path)) + else: + self._path = None + self._object = {} + + self._glyphSet = None + self._scheduledForDeletion = [] # this is a place for storing glyphs that need to be removed when the font is saved + + self.kerning = RKerning() + self.kerning.setParent(self) + self.info = RInfo() + self.info.setParent(self) + self.features = RFeatures() + self.features.setParent(self) + self.groups = RGroups() + self.groups.setParent(self) + self.lib = RLib() + self.lib.setParent(self) + if path: + self._loadData(path) + else: + self.psHints = PostScriptFontHintValues(self) + self.psHints.setParent(self) + + def __setitem__(self, glyphName, glyph): + """Set a glyph at key.""" + self._object[glyphName] = glyph + + def __cmp__(self, other): + """Compare this font with another, compare if they refer to the same file.""" + if not hasattr(other, '_path'): + return -1 + if self._object._path == other._object._path and self._object._path is not None: + return 0 + else: + return -1 + + def __len__(self): + if self._glyphSet is None: + return 0 + return len(self._glyphSet) + + def _loadData(self, path): + from robofab.ufoLib import UFOReader + reader = UFOReader(path) + fontLib = reader.readLib() + # info + reader.readInfo(self.info) + # kerning + self.kerning.update(reader.readKerning()) + self.kerning.setChanged(False) + # groups + self.groups.update(reader.readGroups()) + # features + if reader.formatVersion == 1: + # migrate features from the lib + features = [] + classes = fontLib.get("org.robofab.opentype.classes") + if classes is not None: + del fontLib["org.robofab.opentype.classes"] + features.append(classes) + splitFeatures = fontLib.get("org.robofab.opentype.features") + if splitFeatures is not None: + order = fontLib.get("org.robofab.opentype.featureorder") + if order is None: + order = splitFeatures.keys() + order.sort() + else: + del fontLib["org.robofab.opentype.featureorder"] + del fontLib["org.robofab.opentype.features"] + for tag in order: + oneFeature = splitFeatures.get(tag) + if oneFeature is not None: + features.append(oneFeature) + features = "\n".join(features) + else: + features = reader.readFeatures() + self.features.text = features + # hint data + self.psHints = PostScriptFontHintValues(self) + if postScriptHintDataLibKey in fontLib: + del fontLib[postScriptHintDataLibKey] + # lib + self.lib.update(fontLib) + # glyphs + self._glyphSet = reader.getGlyphSet() + self._hasNotChanged(doGlyphs=False) + + def _loadGlyph(self, glyphName): + """Load a single glyph from the glyphSet, on request.""" + from robofab.pens.rfUFOPen import RFUFOPointPen + g = RGlyph() + g.name = glyphName + pen = RFUFOPointPen(g) + self._glyphSet.readGlyph(glyphName=glyphName, glyphObject=g, pointPen=pen) + g.setParent(self) + g.psHints._loadFromLib(g.lib) + self._object[glyphName] = g + self._object[glyphName]._hasNotChanged() + return g + + #def _prepareSaveDir(self, dir): + # path = os.path.join(dir, 'glyphs') + # if not os.path.exists(path): + # os.makedirs(path) + + def _hasNotChanged(self, doGlyphs=True): + #set the changed state of the font + if doGlyphs: + for glyph in self: + glyph._hasNotChanged() + self.setChanged(False) + + # + # attributes + # + + def _get_path(self): + return self._path + + path = property(_get_path, doc="path of the font") + + # + # methods for imitating GlyphSet? + # + + def keys(self): + # the keys are the superset of self._objects.keys() and + # self._glyphSet.keys(), minus self._scheduledForDeletion + keys = self._object.keys() + if self._glyphSet is not None: + keys.extend(self._glyphSet.keys()) + d = dict() + for glyphName in keys: + d[glyphName] = None + for glyphName in self._scheduledForDeletion: + if glyphName in d: + del d[glyphName] + return d.keys() + + def has_key(self, glyphName): + # XXX ditto, see above. + if self._glyphSet is not None: + hasGlyph = glyphName in self._object or glyphName in self._glyphSet + else: + hasGlyph = glyphName in self._object + return hasGlyph and not glyphName in self._scheduledForDeletion + + __contains__ = has_key + + def getWidth(self, glyphName): + if self._object.has_key(glyphName): + return self._object[glyphName].width + raise IndexError # or return None? + + def getReverseComponentMapping(self): + """ + Get a reversed map of component references in the font. + { + 'A' : ['Aacute', 'Aring'] + 'acute' : ['Aacute'] + 'ring' : ['Aring'] + etc. + } + """ + # a NON-REVERESED map is stored in the lib. + # this is done because a reveresed map could + # contain faulty data. for example: "Aacute" contains + # a component that references "A". Glyph "Aacute" is + # then deleted. The reverse map would still say that + # "A" is referenced by "Aacute" even though the + # glyph has been deleted. So, the stored lib works like this: + # { + # 'Aacute' : [ + # # the last known mod time of the GLIF + # 1098706856.75, + # # component references in a glyph + # ['A', 'acute'] + # ] + # } + import time + import os + import re + componentSearch_RE = re.compile( + "<component\s+" # <component + "[^>]*?" # anything EXCEPT > + "base\s*=\s*[\"\']" # base=" + "(.*?)" # foo + "[\"\']" # " + ) + rightNow = time.time() + libKey = "org.robofab.componentMapping" + previousMap = None + if self.lib.has_key(libKey): + previousMap = self.lib[libKey] + basicMap = {} + reverseMap = {} + for glyphName in self.keys(): + componentsToMap = None + modTime = None + # get the previous bits of data + previousModTime = None + previousList = None + if previousMap is not None and previousMap.has_key(glyphName): + previousModTime, previousList = previousMap[glyphName] + # the glyph has been loaded. + # simply get the components from it. + if self._object.has_key(glyphName): + componentsToMap = [component.baseGlyph for component in self._object[glyphName].components] + # the glyph has not been loaded. + else: + glyphPath = os.path.join(self._glyphSet.dirName, self._glyphSet.contents[glyphName]) + scanGlyph = True + # test the modified time of the GLIF + fileModTime = os.path.getmtime(glyphPath) + if previousModTime is not None and fileModTime == previousModTime: + # the GLIF almost* certianly has not changed. + # *theoretically, a user could replace a GLIF + # with another GLIF that has precisely the same + # mod time. + scanGlyph = False + componentsToMap = previousList + modTime = previousModTime + else: + # the GLIF is different + modTime = fileModTime + if scanGlyph: + # use regex to extract component + # base glyphs from the file + f = open(glyphPath, 'rb') + data = f.read() + f.close() + componentsToMap = componentSearch_RE.findall(data) + if componentsToMap is not None: + # store the non-reversed map + basicMap[glyphName] = (modTime, componentsToMap) + # reverse the map for the user + if componentsToMap: + for baseGlyphName in componentsToMap: + if not reverseMap.has_key(baseGlyphName): + reverseMap[baseGlyphName] = [] + reverseMap[baseGlyphName].append(glyphName) + # if a glyph has been loaded, we do not store data about it in the lib. + # this is done becuase there is not way to determine the proper mod time + # for a loaded glyph. + if modTime is None: + del basicMap[glyphName] + # store the map in the lib for re-use + self.lib[libKey] = basicMap + return reverseMap + + + def save(self, destDir=None, doProgress=False, formatVersion=2): + """Save the Font in UFO format.""" + # XXX note that when doing "save as" by specifying the destDir argument + # _all_ glyphs get loaded into memory. This could be optimized by either + # copying those .glif files that have not been edited or (not sure how + # well that would work) by simply clearing out self._objects after the + # save. + from robofab.ufoLib import UFOWriter + from robofab.tools.fontlabFeatureSplitter import splitFeaturesForFontLab + # if no destination is given, or if + # the given destination is the current + # path, this is not a save as operation + if destDir is None or destDir == self._path: + saveAs = False + destDir = self._path + else: + saveAs = True + # start a progress bar + nonGlyphCount = 5 + bar = None + if doProgress: + from robofab.interface.all.dialogs import ProgressBar + bar = ProgressBar("Exporting UFO", nonGlyphCount + len(self._object.keys())) + # write + writer = UFOWriter(destDir, formatVersion=formatVersion) + try: + # make a shallow copy of the lib. stuff may be added to it. + fontLib = dict(self.lib) + # info + if bar: + bar.label("Saving info...") + writer.writeInfo(self.info) + if bar: + bar.tick() + # kerning + if self.kerning.changed or saveAs: + if bar: + bar.label("Saving kerning...") + writer.writeKerning(self.kerning.asDict()) + if bar: + bar.tick() + # groups + if bar: + bar.label("Saving groups...") + writer.writeGroups(self.groups) + if bar: + bar.tick() + # features + if bar: + bar.label("Saving features...") + features = self.features.text + if features is None: + features = "" + if formatVersion == 2: + writer.writeFeatures(features) + elif formatVersion == 1: + classes, features = splitFeaturesForFontLab(features) + if classes: + fontLib["org.robofab.opentype.classes"] = classes.strip() + "\n" + if features: + featureDict = {} + for featureName, featureText in features: + featureDict[featureName] = featureText.strip() + "\n" + fontLib["org.robofab.opentype.features"] = featureDict + fontLib["org.robofab.opentype.featureorder"] = [featureName for featureName, featureText in features] + if bar: + bar.tick() + # lib + if formatVersion == 1: + fontLib[postScriptHintDataLibKey] = self.psHints.asDict() + if bar: + bar.label("Saving lib...") + writer.writeLib(fontLib) + if bar: + bar.tick() + # glyphs + glyphNameToFileNameFunc = self.getGlyphNameToFileNameFunc() + + glyphSet = writer.getGlyphSet(glyphNameToFileNameFunc) + if len(self._scheduledForDeletion) != 0: + if bar: + bar.label("Removing deleted glyphs...") + for glyphName in self._scheduledForDeletion: + if glyphSet.has_key(glyphName): + glyphSet.deleteGlyph(glyphName) + if bar: + bar.tick() + if bar: + bar.label("Saving glyphs...") + count = nonGlyphCount + if saveAs: + glyphNames = self.keys() + else: + glyphNames = self._object.keys() + for glyphName in glyphNames: + glyph = self[glyphName] + glyph.psHints._saveToLib(glyph.lib) + glyph._saveToGlyphSet(glyphSet, glyphName=glyphName, force=saveAs) + if bar and not count % 10: + bar.tick(count) + count = count + 1 + glyphSet.writeContents() + self._glyphSet = glyphSet + # only blindly stop if the user says to + except KeyboardInterrupt: + bar.close() + bar = None + # kill the progress bar + if bar: + bar.close() + # reset internal stuff + self._path = destDir + self._scheduledForDeletion = [] + self.setChanged(False) + + def newGlyph(self, glyphName, clear=True): + """Make a new glyph with glyphName + if the glyph exists and clear=True clear the glyph""" + if clear and glyphName in self: + g = self[glyphName] + g.clear() + w = self.info.postscriptDefaultWidthX + if w is None: + w = 0 + g.width = w + return g + g = RGlyph() + g.setParent(self) + g.name = glyphName + w = self.info.postscriptDefaultWidthX + if w is None: + w = 0 + g.width = w + g._hasChanged() + self._object[glyphName] = g + # is the user adding a glyph that has the same + # name as one that was deleted earlier? + if glyphName in self._scheduledForDeletion: + self._scheduledForDeletion.remove(glyphName) + return self.getGlyph(glyphName) + + def insertGlyph(self, glyph, name=None): + """returns a new glyph that has been inserted into the font""" + if name is None: + name = glyph.name + glyph = glyph.copy() + glyph.name = name + glyph.setParent(self) + glyph._hasChanged() + self._object[name] = glyph + # is the user adding a glyph that has the same + # name as one that was deleted earlier? + if name in self._scheduledForDeletion: + self._scheduledForDeletion.remove(name) + return self.getGlyph(name) + + def removeGlyph(self, glyphName): + """remove a glyph from the font""" + # XXX! Potential issue with removing glyphs. + # if a glyph is removed from a font, but it is still referenced + # by a component, it will give pens some trouble. + # where does the resposibility for catching this fall? + # the removeGlyph method? the addComponent method + # of the various pens? somewhere else? hm... tricky. + # + #we won't actually remove it, we will just store it for removal + # but only if the glyph does exist + if self.has_key(glyphName) and glyphName not in self._scheduledForDeletion: + self._scheduledForDeletion.append(glyphName) + # now delete the object + if self._object.has_key(glyphName): + del self._object[glyphName] + self._hasChanged() + + def getGlyph(self, glyphName): + # XXX getGlyph may have to become private, to avoid duplication + # with __getitem__ + n = None + if self._object.has_key(glyphName): + # have we served this glyph before? it should be in _object + n = self._object[glyphName] + else: + # haven't served it before, is it in the glyphSet then? + if self._glyphSet is not None and glyphName in self._glyphSet: + # yes, read the .glif file from disk + n = self._loadGlyph(glyphName) + if n is None: + raise KeyError, glyphName + return n + + +class RGlyph(BaseGlyph): + + _title = "RGlyph" + + def __init__(self): + BaseGlyph.__init__(self) + self.contours = [] + self.components = [] + self.anchors = [] + self._unicodes = [] + self.width = 0 + self.note = None + self._name = "Unnamed Glyph" + self.selected = False + self._properties = None + self._lib = RLib() + self._lib.setParent(self) + self.psHints = PostScriptGlyphHintValues() + self.psHints.setParent(self) + + def __len__(self): + return len(self.contours) + + def __getitem__(self, index): + if index < len(self.contours): + return self.contours[index] + raise IndexError + + def _hasNotChanged(self): + for contour in self.contours: + contour.setChanged(False) + for segment in contour.segments: + segment.setChanged(False) + for point in segment.points: + point.setChanged(False) + for component in self.components: + component.setChanged(False) + for anchor in self.anchors: + anchor.setChanged(False) + self.setChanged(False) + + # + # attributes + # + + def _get_lib(self): + return self._lib + + def _set_lib(self, obj): + self._lib.clear() + self._lib.update(obj) + + lib = property(_get_lib, _set_lib) + + def _get_name(self): + return self._name + + def _set_name(self, value): + prevName = self._name + newName = value + if newName == prevName: + return + self._name = newName + self.setChanged(True) + font = self.getParent() + if font is not None: + # but, this glyph could be linked to a + # FontLab font, because objectsFL.RGlyph.copy() + # creates an objectsRF.RGlyph with the parent + # set to an objectsFL.RFont object. so, check to see + # if this is a legitimate RFont before trying to + # do the objectsRF.RFont glyph name change + if isinstance(font, RFont): + font._object[newName] = self + # is the user changing a glyph's name to the + # name of a glyph that was deleted earlier? + if newName in font._scheduledForDeletion: + font._scheduledForDeletion.remove(newName) + font.removeGlyph(prevName) + + name = property(_get_name, _set_name) + + def _get_unicodes(self): + return self._unicodes + + def _set_unicodes(self, value): + if not isinstance(value, list): + raise RoboFabError, "unicodes must be a list" + self._unicodes = value + self._hasChanged() + + unicodes = property(_get_unicodes, _set_unicodes, doc="all unicode values for the glyph") + + def _get_unicode(self): + if len(self._unicodes) == 0: + return None + return self._unicodes[0] + + def _set_unicode(self, value): + uni = self._unicodes + if value is not None: + if value not in uni: + self.unicodes.insert(0, value) + elif uni.index(value) != 0: + uni.insert(0, uni.pop(uni.index(value))) + self.unicodes = uni + + unicode = property(_get_unicode, _set_unicode, doc="first unicode value for the glyph") + + def getPointPen(self): + from robofab.pens.rfUFOPen import RFUFOPointPen + return RFUFOPointPen(self) + + def appendComponent(self, baseGlyph, offset=(0, 0), scale=(1, 1)): + """append a component to the glyph""" + new = RComponent(baseGlyph, offset, scale) + new.setParent(self) + self.components.append(new) + self._hasChanged() + + def appendAnchor(self, name, position, mark=None): + """append an anchor to the glyph""" + new = RAnchor(name, position, mark) + new.setParent(self) + self.anchors.append(new) + self._hasChanged() + + def removeContour(self, index): + """remove a specific contour from the glyph""" + del self.contours[index] + self._hasChanged() + + def removeAnchor(self, anchor): + """remove a specific anchor from the glyph""" + del self.anchors[anchor.index] + self._hasChanged() + + def removeComponent(self, component): + """remove a specific component from the glyph""" + del self.components[component.index] + self._hasChanged() + + def center(self, padding=None): + """Equalise sidebearings, set to padding if wanted.""" + left = self.leftMargin + right = self.rightMargin + if padding: + e_left = e_right = padding + else: + e_left = (left + right)/2 + e_right = (left + right) - e_left + self.leftMargin = e_left + self.rightMargin = e_right + + def decompose(self): + """Decompose all components""" + for i in range(len(self.components)): + self.components[-1].decompose() + self._hasChanged() + + def clear(self, contours=True, components=True, anchors=True, guides=True): + """Clear all items marked as True from the glyph""" + if contours: + self.clearContours() + if components: + self.clearComponents() + if anchors: + self.clearAnchors() + if guides: + self.clearHGuides() + self.clearVGuides() + + def clearContours(self): + """clear all contours""" + self.contours = [] + self._hasChanged() + + def clearComponents(self): + """clear all components""" + self.components = [] + self._hasChanged() + + def clearAnchors(self): + """clear all anchors""" + self.anchors = [] + self._hasChanged() + + def clearHGuides(self): + """clear all horizontal guides""" + self.hGuides = [] + self._hasChanged() + + def clearVGuides(self): + """clear all vertical guides""" + self.vGuides = [] + self._hasChanged() + + def getAnchors(self): + return self.anchors + + def getComponents(self): + return self.components + + # + # stuff related to Glyph Properties + # + + + +class RContour(BaseContour): + + _title = "RoboFabContour" + + def __init__(self, object=None): + #BaseContour.__init__(self) + self.segments = [] + self.selected = False + + def __len__(self): + return len(self.segments) + + def __getitem__(self, index): + if index < len(self.segments): + return self.segments[index] + raise IndexError + + def _get_index(self): + return self.getParent().contours.index(self) + + def _set_index(self, index): + ogIndex = self.index + if index != ogIndex: + contourList = self.getParent().contours + contourList.insert(index, contourList.pop(ogIndex)) + + + index = property(_get_index, _set_index, doc="index of the contour") + + def _get_points(self): + points = [] + for segment in self.segments: + for point in segment.points: + points.append(point) + return points + + points = property(_get_points, doc="view the contour as a list of points") + + def _get_bPoints(self): + bPoints = [] + for segment in self.segments: + segType = segment.type + if segType == MOVE: + bType = CORNER + elif segType == LINE: + bType = CORNER + elif segType == CURVE: + if segment.smooth: + bType = CURVE + else: + bType = CORNER + else: + raise RoboFabError, "encountered unknown segment type" + b = RBPoint() + b.setParent(segment) + bPoints.append(b) + return bPoints + + bPoints = property(_get_bPoints, doc="view the contour as a list of bPoints") + + def appendSegment(self, segmentType, points, smooth=False): + """append a segment to the contour""" + segment = self.insertSegment(index=len(self.segments), segmentType=segmentType, points=points, smooth=smooth) + return segment + + def insertSegment(self, index, segmentType, points, smooth=False): + """insert a segment into the contour""" + segment = RSegment(segmentType, points, smooth) + segment.setParent(self) + self.segments.insert(index, segment) + self._hasChanged() + return segment + + def removeSegment(self, index): + """remove a segment from the contour""" + del self.segments[index] + self._hasChanged() + + def reverseContour(self): + """reverse the contour""" + from robofab.pens.reverseContourPointPen import ReverseContourPointPen + index = self.index + glyph = self.getParent() + pen = glyph.getPointPen() + reversePen = ReverseContourPointPen(pen) + self.drawPoints(reversePen) + # we've drawn the reversed contour onto our parent glyph, + # so it sits at the end of the contours list: + newContour = glyph.contours.pop(-1) + for segment in newContour.segments: + segment.setParent(self) + self.segments = newContour.segments + self._hasChanged() + + def setStartSegment(self, segmentIndex): + """set the first segment on the contour""" + # this obviously does not support open contours + if len(self.segments) < 2: + return + if segmentIndex == 0: + return + if segmentIndex > len(self.segments)-1: + raise IndexError, 'segment index not in segments list' + oldStart = self.segments[0] + oldLast = self.segments[-1] + #check to see if the contour ended with a curve on top of the move + #if we find one delete it, + if oldLast.type == CURVE or oldLast.type == QCURVE: + startOn = oldStart.onCurve + lastOn = oldLast.onCurve + if startOn.x == lastOn.x and startOn.y == lastOn.y: + del self.segments[0] + # since we deleted the first contour, the segmentIndex needs to shift + segmentIndex = segmentIndex - 1 + # if we DO have a move left over, we need to convert it to a line + if self.segments[0].type == MOVE: + self.segments[0].type = LINE + # slice up the segments and reassign them to the contour + segments = self.segments[segmentIndex:] + self.segments = segments + self.segments[:segmentIndex] + # now, draw the contour onto the parent glyph + glyph = self.getParent() + pen = glyph.getPointPen() + self.drawPoints(pen) + # we've drawn the new contour onto our parent glyph, + # so it sits at the end of the contours list: + newContour = glyph.contours.pop(-1) + for segment in newContour.segments: + segment.setParent(self) + self.segments = newContour.segments + self._hasChanged() + + +class RSegment(BaseSegment): + + _title = "RoboFabSegment" + + def __init__(self, segmentType=None, points=[], smooth=False): + BaseSegment.__init__(self) + self.selected = False + self.points = [] + self.smooth = smooth + if points: + #the points in the segment should be RPoints, so create those objects + for point in points[:-1]: + x, y = point + p = RPoint(x, y, pointType=OFFCURVE) + p.setParent(self) + self.points.append(p) + aX, aY = points[-1] + p = RPoint(aX, aY, segmentType) + p.setParent(self) + self.points.append(p) + + def _get_type(self): + return self.points[-1].type + + def _set_type(self, pointType): + onCurve = self.points[-1] + ocType = onCurve.type + if ocType == pointType: + return + #we are converting a cubic line into a cubic curve + if pointType == CURVE and ocType == LINE: + onCurve.type = pointType + parent = self.getParent() + prev = parent._prevSegment(self.index) + p1 = RPoint(prev.onCurve.x, prev.onCurve.y, pointType=OFFCURVE) + p1.setParent(self) + p2 = RPoint(onCurve.x, onCurve.y, pointType=OFFCURVE) + p2.setParent(self) + self.points.insert(0, p2) + self.points.insert(0, p1) + #we are converting a cubic move to a curve + elif pointType == CURVE and ocType == MOVE: + onCurve.type = pointType + parent = self.getParent() + prev = parent._prevSegment(self.index) + p1 = RPoint(prev.onCurve.x, prev.onCurve.y, pointType=OFFCURVE) + p1.setParent(self) + p2 = RPoint(onCurve.x, onCurve.y, pointType=OFFCURVE) + p2.setParent(self) + self.points.insert(0, p2) + self.points.insert(0, p1) + #we are converting a quad curve to a cubic curve + elif pointType == CURVE and ocType == QCURVE: + onCurve.type == CURVE + #we are converting a cubic curve into a cubic line + elif pointType == LINE and ocType == CURVE: + p = self.points.pop(-1) + self.points = [p] + onCurve.type = pointType + self.smooth = False + #we are converting a cubic move to a line + elif pointType == LINE and ocType == MOVE: + onCurve.type = pointType + #we are converting a quad curve to a line: + elif pointType == LINE and ocType == QCURVE: + p = self.points.pop(-1) + self.points = [p] + onCurve.type = pointType + self.smooth = False + # we are converting to a quad curve where just about anything is legal + elif pointType == QCURVE: + onCurve.type = pointType + else: + raise RoboFabError, 'unknown segment type' + + type = property(_get_type, _set_type, doc="type of the segment") + + def _get_index(self): + return self.getParent().segments.index(self) + + index = property(_get_index, doc="index of the segment") + + def insertPoint(self, index, pointType, point): + x, y = point + p = RPoint(x, y, pointType=pointType) + p.setParent(self) + self.points.insert(index, p) + self._hasChanged() + + def removePoint(self, index): + del self.points[index] + self._hasChanged() + + +class RBPoint(BaseBPoint): + + _title = "RoboFabBPoint" + + def _setAnchorChanged(self, value): + self._anchorPoint.setChanged(value) + + def _setNextChanged(self, value): + self._nextOnCurve.setChanged(value) + + def _get__parentSegment(self): + return self.getParent() + + _parentSegment = property(_get__parentSegment, doc="") + + def _get__nextOnCurve(self): + pSeg = self._parentSegment + contour = pSeg.getParent() + #could this potentially return an incorrect index? say, if two segments are exactly the same? + return contour.segments[(contour.segments.index(pSeg) + 1) % len(contour.segments)] + + _nextOnCurve = property(_get__nextOnCurve, doc="") + + def _get_index(self): + return self._parentSegment.index + + index = property(_get_index, doc="index of the bPoint on the contour") + + +class RPoint(BasePoint): + + _title = "RoboFabPoint" + + def __init__(self, x=0, y=0, pointType=None, name=None): + self.selected = False + self._type = pointType + self._x = x + self._y = y + self._name = name + + def _get_x(self): + return self._x + + def _set_x(self, value): + self._x = value + self._hasChanged() + + x = property(_get_x, _set_x, doc="") + + def _get_y(self): + return self._y + + def _set_y(self, value): + self._y = value + self._hasChanged() + + y = property(_get_y, _set_y, doc="") + + def _get_type(self): + return self._type + + def _set_type(self, value): + self._type = value + self._hasChanged() + + type = property(_get_type, _set_type, doc="") + + def _get_name(self): + return self._name + + def _set_name(self, value): + self._name = value + self._hasChanged() + + name = property(_get_name, _set_name, doc="") + + +class RAnchor(BaseAnchor): + + _title = "RoboFabAnchor" + + def __init__(self, name=None, position=None, mark=None): + BaseAnchor.__init__(self) + self.selected = False + self.name = name + if position is None: + self.x = self.y = None + else: + self.x, self.y = position + self.mark = mark + + def _get_index(self): + if self.getParent() is None: return None + return self.getParent().anchors.index(self) + + index = property(_get_index, doc="index of the anchor") + + def _get_position(self): + return (self.x, self.y) + + def _set_position(self, value): + self.x = value[0] + self.y = value[1] + self._hasChanged() + + position = property(_get_position, _set_position, doc="position of the anchor") + + def move(self, pt): + """Move the anchor""" + self.x = self.x + pt[0] + self.y = self.y + pt[0] + self._hasChanged() + + +class RComponent(BaseComponent): + + _title = "RoboFabComponent" + + def __init__(self, baseGlyphName=None, offset=(0,0), scale=(1,1), transform=None): + BaseComponent.__init__(self) + self.selected = False + self._baseGlyph = baseGlyphName + self._offset = offset + self._scale = scale + if transform is None: + xx, yy = scale + dx, dy = offset + self.transformation = (xx, 0, 0, yy, dx, dy) + else: + self.transformation = transform + + def _get_index(self): + if self.getParent() is None: return None + return self.getParent().components.index(self) + + index = property(_get_index, doc="index of the component") + + def _get_baseGlyph(self): + return self._baseGlyph + + def _set_baseGlyph(self, glyphName): + # XXXX needs to be implemented in objectsFL for symmetricity's sake. Eventually. + self._baseGlyph = glyphName + self._hasChanged() + + baseGlyph = property(_get_baseGlyph, _set_baseGlyph, doc="") + + def _get_offset(self): + """ Get the offset component of the transformation.=""" + (xx, xy, yx, yy, dx, dy) = self._transformation + return dx, dy + + def _set_offset(self, value): + """ Set the offset component of the transformation.""" + (xx, xy, yx, yy, dx, dy) = self._transformation + self._transformation = (xx, xy, yx, yy, value[0], value[1]) + self._hasChanged() + + offset = property(_get_offset, _set_offset, doc="the offset of the component") + + def _get_scale(self): + """ Return the scale components of the transformation.""" + (xx, xy, yx, yy, dx, dy) = self._transformation + return xx, yy + + def _set_scale(self, scale): + """ Set the scale component of the transformation. + Note: setting this value effectively makes the xy and yx values meaningless. + We're assuming that if you're setting the xy and yx values, you will use + the transformation attribute rather than the scale and offset attributes. + """ + xScale, yScale = scale + (xx, xy, yx, yy, dx, dy) = self._transformation + self._transformation = (xScale, xy, yx, yScale, dx, dy) + self._hasChanged() + + scale = property(_get_scale, _set_scale, doc="the scale of the component") + + def _get_transformation(self): + return self._transformation + + def _set_transformation(self, transformation): + assert len(transformation)==6, "Transformation matrix must have 6 values" + self._transformation = transformation + + transformation = property(_get_transformation, _set_transformation, doc="the transformation matrix of the component") + + def move(self, pt): + """Move the component""" + (xx, xy, yx, yy, dx, dy) = self._transformation + self._transformation = (xx, xy, yx, yy, dx+pt[0], dy+pt[1]) + self._hasChanged() + + def decompose(self): + """Decompose the component""" + baseGlyphName = self.baseGlyph + parentGlyph = self.getParent() + # if there is no parent glyph, there is nothing to decompose to + if baseGlyphName is not None and parentGlyph is not None: + parentFont = parentGlyph.getParent() + # we must have a parent glyph with the baseGlyph + # if not, we will simply remove the component from + # the parent glyph thereby decomposing the component + # to nothing. + if parentFont is not None and parentFont.has_key(baseGlyphName): + from robofab.pens.adapterPens import TransformPointPen + baseGlyph = parentFont[baseGlyphName] + for contour in baseGlyph.contours: + pointPen = parentGlyph.getPointPen() + transPen = TransformPointPen(pointPen, self._transformation) + contour.drawPoints(transPen) + parentGlyph.components.remove(self) + + +class RKerning(BaseKerning): + + _title = "RoboFabKerning" + + +class RGroups(BaseGroups): + + _title = "RoboFabGroups" + +class RLib(BaseLib): + + _title = "RoboFabLib" + + +class RInfo(BaseInfo): + + _title = "RoboFabFontInfo" + +class RFeatures(BaseFeatures): + + _title = "RoboFabFeatures" + |