| | |
- Feature
- __builtin__.dict(__builtin__.object)
-
- FeatureSet
class Feature |
| |
Feature contains one single feature, of any flavor.
Read from feature script
Write to feature script
Read from simple dict
Write to simple dict
Parse some of the lines
Accept edits and additions
|
| |
Methods defined here:
- __init__(self, name=None, text=None, data=None, interpret=True)
- __repr__(self)
- addPos(self, itemOne, itemTwo, offset)
- Add a positioning statement
- addSub(self, itemsIn, itemsOut, subType=0)
- Add a substitution statement
- asDict(self)
- Return the data of this feature as a plist ready dictionary
- fromDict(self, aDict)
- Read the data from a dict.
- hasPos(self)
- Return True if this feature has positioning defined.
- hasSubs(self)
- Return True if this feature has substitutions defined.
- parse(self, featureText)
- bluntly split the lines of feature code as they come from fontlab
This doesn't by any means parse all of the possible combinations
in a .fea file. It parses the pos and sub lines defines within a feature.
Something higher up should parse the seperate features from the .fea.
It doesn't check for validity of the lines.
- readFeatureText(self, featureText, interpret=True)
- Read the feature text and try to make sense of it.
Note: Should you want to preserve the actual featuretext
rather than the intrepreted data, set interpret = False
In case the feature text isn't properly interpreted
(possible) or because the feature text is hand edited
and you just want it to round trip to UFO.
- writeFeatureText(self, wrapped=True)
- return the feature as an OpenType feature string
wrapped = True: wrapped with featurename { feature items; }
wrapped = False: similar to that produced by FontLab
|
class FeatureSet(__builtin__.dict) |
| |
A dict to combine all features, and write them to various places
|
| |
- Method resolution order:
- FeatureSet
- __builtin__.dict
- __builtin__.object
Methods defined here:
- __init__(self, interpret=True)
- append(self, aFeature)
- Append a feature object to this set
- asDict(self)
- Return a dict with all features also written out as dicts. Not the same as self.
Data is ready for writing to plist
- newFeature(self, name)
- Add a new feature and return it
- readFL(self, aFont)
- Read the feature stuff from a RFont in FL context.
This can be structured better I think, but let's get
something working first.
- readLib(self, aFont)
- Read the feature stuff from the font lib.
Rather than add all this to yet another file in the UFO,
just store it in the lib. UFO users will be able to read
the data anyway.
- update(self, aDict)
- Accept a dictionary with all features written out as dicts.
Ready for data read from plist
- writeFL(self, aFont, featureName=None)
- Write one or all features back
- writeLib(self, aFont)
Data and other attributes defined here:
- __dict__ = <dictproxy object at 0x129c650>
- dictionary for instance variables (if defined)
- __weakref__ = <attribute '__weakref__' of 'FeatureSet' objects>
- list of weak references to the object (if defined)
Methods inherited from __builtin__.dict:
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __contains__(...)
- x.__contains__(y) <==> y in x
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __iter__(...)
- x.__iter__() <==> iter(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- clear(...)
- D.clear() -> None. Remove all items from D.
- copy(...)
- D.copy() -> a shallow copy of D
- get(...)
- D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
- has_key(...)
- D.has_key(k) -> True if D has a key k, else False
- items(...)
- D.items() -> list of D's (key, value) pairs, as 2-tuples
- iteritems(...)
- D.iteritems() -> an iterator over the (key, value) items of D
- iterkeys(...)
- D.iterkeys() -> an iterator over the keys of D
- itervalues(...)
- D.itervalues() -> an iterator over the values of D
- keys(...)
- D.keys() -> list of D's keys
- pop(...)
- D.pop(k[,d]) -> v, remove specified key and return the corresponding value
If key is not found, d is returned if given, otherwise KeyError is raised
- popitem(...)
- D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty
- setdefault(...)
- D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
- values(...)
- D.values() -> list of D's values
Data and other attributes inherited from __builtin__.dict:
- __new__ = <built-in method __new__ of type object at 0xa866d054>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
- fromkeys = <built-in method fromkeys of type object at 0x115f420>
- dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
| |