class AccentedMaker(BaseWindowController):
fontOptions = []
whichFont = None
actions = ['Place Anchors', 'Build Accents']
whichAction = actions[0]
whichGlyphList = None
markEditedGlyphs = False
markColor = glyphCollectionColors[glyphCollectionColors.keys()[0]]
uppercaseAccents = False
def __init__(self):
super(AccentedMaker, self).__init__()
self.initLogger()
self.fontOptions = ['All Fonts', 'Current Font'] + AllFonts()
self.whichFont = self.fontOptions[0]
self.pluginHeight = PLUGIN_HEIGHT
self.loadAccentedData()
self.parseGlyphListsFromAccentedData()
firstKey = self.glyphLists[self.whichAction].keys()[0]
self.whichGlyphList = self.glyphLists[self.whichAction][firstKey]
self.w = FloatingWindow((0, 0, PLUGIN_WIDTH, self.pluginHeight),
PLUGIN_TITLE)
self.w.sharedCtrls = SharedCtrls(
(MARGIN_HOR, MARGIN_VER, NET_WIDTH, 104),
fontOptions=self.fontOptions,
whichFont=self.whichFont,
actions=self.actions,
whichAction=self.whichAction,
glyphLists=self.glyphLists,
whichGlyphList=self.whichGlyphList,
markColor=self.markColor,
markEditedGlyphs=self.markEditedGlyphs,
callback=self.sharedCtrlsCallback)
self.w.separationLine = HorizontalLine(
(MARGIN_HOR, self.w.sharedCtrls.getPosSize()[3] + MARGIN_ROW,
NET_WIDTH, vanillaControlsSize['HorizontalLineThickness']))
dependantCtrlsHgt = MARGIN_VER + self.w.sharedCtrls.getPosSize(
)[3] + MARGIN_ROW
self.w.anchorsCtrls = AnchorsCtrls(
(MARGIN_HOR, dependantCtrlsHgt, NET_WIDTH, 76),
callbackAttrs=self.anchorsVarsCallback,
placeCallback=self.anchorsPlaceCallback,
deleteCallback=self.anchorsDeleteCallback)
self.w.buildingCtrls = BuildingCtrls(
(MARGIN_HOR, dependantCtrlsHgt, NET_WIDTH, 50),
self.uppercaseAccents,
callbackAttrs=self.buildingVarsCallback,
callbackCheck=self.checkAccentedCallback,
callbackBuild=self.buildAccentedCallback)
self.w.buildingCtrls.show(False)
addObserver(self, 'updateFontOptions', "newFontDidOpen")
addObserver(self, 'updateFontOptions', "fontDidOpen")
addObserver(self, 'updateFontOptions', "fontWillClose")
self.w.bind("close", self.windowCloseCallback)
self.setUpBaseWindowBehavior()
self.adjustPluginHeight()
self.w.open()
def initLogger(self):
# create a logger
self.accentedLogger = logging.getLogger('accentedLogger')
# create file handler which logs info messages
fileBasedHandler = logging.FileHandler('accentedLettersMaker.log')
fileBasedHandler.setLevel(logging.INFO)
# create console handler with a higher log level, only errors
consoleHandler = logging.StreamHandler()
consoleHandler.setLevel(logging.ERROR)
# create formatter and add it to the handlers
formatter = logging.Formatter(
u'%(asctime)s | %(levelname)s | line: %(lineno)d | %(funcName)s | %(message)s'
)
fileBasedHandler.setFormatter(formatter)
consoleHandler.setFormatter(formatter)
# add the handlers to the logger
self.accentedLogger.addHandler(fileBasedHandler)
self.accentedLogger.addHandler(consoleHandler)
# deal with font data
def prepareFontsToAction(self):
if self.whichFont == 'All Fonts':
fontsToProcess = AllFonts()
elif self.whichFont == 'Current Font':
fontsToProcess = [CurrentFont()]
else:
fontsToProcess = [self.whichFont]
return fontsToProcess
def deleteAnchors(self):
self.accentedLogger.info(
START_FUNC.format(funcName=self.deleteAnchors.__name__))
fontsToProcess = self.prepareFontsToAction()
for eachFont in fontsToProcess:
self.accentedLogger.info(
START_FONT.format(familyName=eachFont.info.familyName,
styleName=eachFont.info.styleName))
for eachGlyphName in self.whichGlyphList:
eachGlyph = eachFont[eachGlyphName]
if self.markEditedGlyphs is True:
if version[0] == '2':
eachGlyph.markColor = self.markColor
else:
eachGlyph.mark = self.markColor
for eachAnchor in eachGlyph.anchors:
eachGlyph.removeAnchor(eachAnchor)
self.accentedLogger.info(
REMOVE_ANCHOR.format(anchorName=self.anchorName,
glyphName=eachGlyphName))
self.accentedLogger.info(
END_FUNC.format(funcName=self.deleteAnchors.__name__))
def placeAnchors(self):
assert self.anchorName is not None, '[WARNING] no anchor name provided'
assert self.anchorHeight is not None, '[WARNING] no anchor height provided'
self.accentedLogger.info(
START_FUNC.format(funcName=self.placeAnchors.__name__))
fontsToProcess = self.prepareFontsToAction()
for eachFont in fontsToProcess:
self.accentedLogger.info(
START_FONT.format(familyName=eachFont.info.familyName,
styleName=eachFont.info.styleName))
for eachGlyphName in self.whichGlyphList:
if eachGlyphName in eachFont:
eachGlyph = eachFont[eachGlyphName]
if self.markEditedGlyphs is True:
if version[0] == '2':
eachGlyph.markColor = self.markColor
else:
eachGlyph.mark = self.markColor
if selectAnchorByName(eachGlyph, self.anchorName):
anchorToDel = selectAnchorByName(
eachGlyph, self.anchorName)
eachGlyph.removeAnchor(anchorToDel)
if version[0] == '2':
xMin, yMin, xMax, yMax = eachGlyph.bounds
else:
xMin, yMin, xMax, yMax = eachGlyph.box
if eachFont.info.italicAngle:
anchorAngle = radians(-eachFont.info.italicAngle)
else:
anchorAngle = radians(0)
tangentOffset = tan(anchorAngle) * self.anchorHeight
anchorX = (
eachGlyph.width - eachGlyph.angledLeftMargin -
eachGlyph.angledRightMargin
) / 2 + eachGlyph.angledLeftMargin + tangentOffset
eachGlyph.appendAnchor(self.anchorName,
(anchorX, self.anchorHeight))
self.accentedLogger.info(
APPEND_ANCHOR.format(anchorName=self.anchorName,
anchorX=anchorX,
anchorHeight=self.anchorHeight,
glyphName=eachGlyphName))
else:
self.accentedLogger.error(
GLYPH_NOT_IN_FONT.format(
glyphName=eachGlyphName,
familyName=eachFont.info.familyName,
styleName=eachFont.info.styleName))
self.accentedLogger.info(
END_FUNC.format(funcName=self.placeAnchors.__name__))
def checkAccented(self, isPrinting=True):
report = []
notReady = OrderedDict()
fontsToProcess = self.prepareFontsToAction()
for eachFont in fontsToProcess:
toSkip = []
report.append('Checking {} {}'.format(eachFont.info.familyName,
eachFont.info.styleName))
for eachAccentedName, eachBaseName, eachAccentName, eachAnchorName in self.whichGlyphList:
# base glyph
if eachFont.has_key(eachBaseName) is False:
report.append(
BUILD_MISSING_GLYPH.format(
glyphName=eachBaseName,
accentedName=eachAccentedName))
if eachAccentedName not in toSkip:
toSkip.append(eachAccentedName)
else:
eachBaseGlyph = eachFont[eachBaseName]
if not eachBaseGlyph.anchors:
report.append(
NO_ANCHORS.format(glyphName=eachBaseName))
if eachAccentedName not in toSkip:
toSkip.append(eachAccentedName)
if version[0] == '2':
eachBaseGlyph.markColor = ERROR_MARK_COLOR
else:
eachBaseGlyph.mark = ERROR_MARK_COLOR
else:
for eachAnchor in eachBaseGlyph.anchors:
if eachAnchor.name == eachAnchorName:
break
else:
report.append(
BUILD_MISSING_ANCHOR.format(
anchorName=eachAnchorName,
glyphName=eachBaseName,
accentedName=eachAccentedName))
if eachAccentedName not in toSkip:
toSkip.append(eachAccentedName)
if version[0] == '2':
eachBaseGlyph.markColor = ERROR_MARK_COLOR
else:
eachBaseGlyph.mark = ERROR_MARK_COLOR
# accent
if eachFont.has_key(eachAccentName) is False:
report.append(
BUILD_MISSING_GLYPH.format(
glyphName=eachAccentName,
accentedName=eachAccentedName))
if eachAccentedName not in toSkip:
toSkip.append(eachAccentedName)
else:
eachAccentGlyph = eachFont[eachAccentName]
if not eachAccentGlyph.anchors:
report.append(
NO_ANCHORS.format(glyphName=eachAccentName))
if eachAccentedName not in toSkip:
toSkip.append(eachAccentedName)
if version[0] == '2':
eachAccentGlyph.markColor = ERROR_MARK_COLOR
else:
eachAccentGlyph.mark = ERROR_MARK_COLOR
else:
for eachAnchor in eachAccentGlyph.anchors:
if eachAnchor.name == '_{}'.format(eachAnchorName):
break
else:
report.append(
BUILD_MISSING_ANCHOR.format(
anchorName=eachAnchorName,
glyphName=eachAccentName,
accentedName=eachAccentedName))
if eachAccentedName not in toSkip:
toSkip.append(eachAccentedName)
if version[0] == '2':
eachAccentGlyph.markColor = ERROR_MARK_COLOR
else:
eachAccentGlyph.mark = ERROR_MARK_COLOR
notReady['{} {}'.format(eachFont.info.familyName,
eachFont.info.styleName)] = toSkip
report.append('End checking {} {}'.format(eachFont.info.familyName,
eachFont.info.styleName))
report.append('\n\n')
if isPrinting is True:
self.accentedLogger.error('\n'.join(report))
return notReady
def buildAccented(self):
notReady = self.checkAccented(isPrinting=False)
self.accentedLogger.info(
START_FUNC.format(funcName=self.buildAccented.__name__))
fontsToProcess = self.prepareFontsToAction()
for eachFont in fontsToProcess:
self.accentedLogger.info(
START_FONT.format(familyName=eachFont.info.familyName,
styleName=eachFont.info.styleName))
for eachAccentedName, eachBaseName, eachAccentName, eachAnchorName in self.whichGlyphList:
if eachAccentedName in notReady['{} {}'.format(
eachFont.info.familyName, eachFont.info.styleName)]:
self.accentedLogger.error(
NOT_READY.format(fontName='{} {}'.format(
eachFont.info.familyName, eachFont.info.styleName),
accentedName=eachAccentedName))
continue
eachBaseGlyph = eachFont[eachBaseName]
eachBaseAnchor = selectAnchorByName(eachBaseGlyph,
eachAnchorName)
eachAccentGlyph = eachFont[eachAccentName]
eachAccentAnchor = selectAnchorByName(
eachAccentGlyph, '_{}'.format(eachAnchorName))
if eachFont.has_key(eachAccentedName) is False:
eachAccentedGlyph = eachFont.newGlyph(eachAccentedName)
else:
eachAccentedGlyph = eachFont[eachAccentedName]
eachAccentedGlyph.clear()
eachAccentedGlyph.width = eachBaseGlyph.width
eachAccentedGlyph.appendComponent(eachBaseName, (0, 0), (1, 1))
accentOffsetX, accentOffsetY = eachBaseAnchor.x - eachAccentAnchor.x, eachBaseAnchor.y - eachAccentAnchor.y
eachAccentedGlyph.appendComponent(
eachAccentName, (accentOffsetX, accentOffsetY), (1, 1))
self.accentedLogger.info(
BUILT_GLYPH.format(accentedName=eachAccentedName,
baseName=eachBaseName,
accentName=eachAccentName,
anchorName=eachAnchorName))
if self.markEditedGlyphs is True:
if version[0] == '2':
eachAccentedGlyph.markColor = self.markColor
else:
eachAccentedGlyph.mark = self.markColor
self.accentedLogger.info(
END_FUNC.format(funcName=self.buildAccented.__name__))
# deal with table data
def loadAccentedData(self):
self.accentedData = [[cell.strip() for cell in row.split('\t')]
for row in open(TABLE_PATH, 'r').readlines()]
def parseGlyphListsFromAccentedData(self):
assert self.accentedData is not None
self.glyphLists = OrderedDict()
# anchors
self.glyphLists['Place Anchors'] = OrderedDict()
accentsTop = []
_ = [
accentsTop.append(row[2]) for row in self.accentedData
if row[3] == 'top' and row[2] not in accentsTop
]
self.glyphLists['Place Anchors']['ACC TOP'] = accentsTop
accentsBtm = []
_ = [
accentsBtm.append(row[2]) for row in self.accentedData
if row[3] == 'bottom' and row[2] not in accentsBtm
]
self.glyphLists['Place Anchors']['ACC BTM'] = accentsBtm
accentsCaseTop = ['{}.case'.format(name) for name in accentsTop]
self.glyphLists['Place Anchors']['ACC CASE TOP'] = accentsCaseTop
accentsCaseBtm = ['{}.case'.format(name) for name in accentsBtm]
self.glyphLists['Place Anchors']['ACC CASE BTM'] = accentsCaseBtm
ucBaseTop = []
_ = [
ucBaseTop.append(row[1]) for row in self.accentedData if
row[1][0].isupper() and row[3] == 'top' and row[1] not in ucBaseTop
]
self.glyphLists['Place Anchors']['UC TOP'] = ucBaseTop
ucBaseBtm = []
_ = [
ucBaseBtm.append(row[1]) for row in self.accentedData
if row[1][0].isupper() and row[3] == 'bottom'
and row[1] not in ucBaseBtm
]
self.glyphLists['Place Anchors']['UC BTM'] = ucBaseBtm
lcBaseTop = []
_ = [
lcBaseTop.append(row[1]) for row in self.accentedData if
row[1][0].islower() and row[3] == 'top' and row[1] not in lcBaseTop
]
self.glyphLists['Place Anchors']['LC TOP'] = lcBaseTop
lcBaseBtm = []
_ = [
lcBaseBtm.append(row[1]) for row in self.accentedData
if row[1][0].islower() and row[3] == 'bottom'
and row[1] not in lcBaseBtm
]
self.glyphLists['Place Anchors']['LC BTM'] = lcBaseBtm
# build
self.glyphLists['Build Accents'] = OrderedDict()
self.glyphLists['Build Accents']['ALL'] = self.accentedData
buildUC = [
row for row in self.accentedData if row[1][0].isupper() is True
]
self.glyphLists['Build Accents']['UC'] = buildUC
buildLC = [
row for row in self.accentedData if row[1][0].islower() is True
]
self.glyphLists['Build Accents']['LC'] = buildLC
# ui
def adjustPluginHeight(self):
if self.whichAction == 'Place Anchors':
self.pluginHeight = MARGIN_VER + self.w.sharedCtrls.getPosSize(
)[3] + MARGIN_ROW + self.w.anchorsCtrls.getPosSize(
)[3] + MARGIN_VER
else:
self.pluginHeight = MARGIN_VER + self.w.sharedCtrls.getPosSize(
)[3] + MARGIN_ROW + self.w.buildingCtrls.getPosSize(
)[3] + MARGIN_VER
lft, top, wdt, hgt = self.w.getPosSize()
self.w.resize(wdt, self.pluginHeight)
def switchDependantCtrl(self):
if self.whichAction == 'Place Anchors':
self.w.anchorsCtrls.show(True)
self.w.buildingCtrls.show(False)
else:
self.w.anchorsCtrls.show(False)
self.w.buildingCtrls.show(True)
# observers
def updateFontOptions(self, sender):
self.fontOptions = ['All Fonts', 'Current Font'] + AllFonts()
self.w.sharedCtrls.setFontOptions(self.fontOptions)
# callbacks
def sharedCtrlsCallback(self, sender):
self.whichFont = sender.getWhichFont()
self.whichAction = sender.getWhichAction()
self.switchDependantCtrl()
self.adjustPluginHeight()
self.whichGlyphList = sender.getWhichGlyphList()
self.markEditedGlyphs, self.markColor = sender.getMarkEditedGlyphs()
def anchorsVarsCallback(self, sender):
self.anchorHeight = sender.getHeight()
self.anchorName = sender.getName()
def anchorsPlaceCallback(self, sender):
self.placeAnchors()
def anchorsDeleteCallback(self, sender):
self.deleteAnchors()
def buildingVarsCallback(self, sender):
self.uppercaseAccents = sender.getUppercaseAccents()
def checkAccentedCallback(self, sender):
self.checkAccented()
def buildAccentedCallback(self, sender):
self.buildAccented()
def windowCloseCallback(self, sender):
removeObserver(self, "newFontDidOpen")
removeObserver(self, "fontDidOpen")
removeObserver(self, "fontWillClose")
super(AccentedMaker, self).windowCloseCallback(sender)
class ToucheTool():
def __init__(self):
NSUserDefaults.standardUserDefaults().registerDefaults_(
{"ToucheWindowHeight": 340})
self.windowHeight = NSUserDefaults.standardUserDefaults(
).integerForKey_("ToucheWindowHeight")
self.minWindowHeight = 340
if self.windowHeight < self.minWindowHeight:
self.windowHeight = self.minWindowHeight
self.closedWindowHeight = 100
self.w = FloatingWindow((180, self.windowHeight),
'Touché!',
minSize=(180, 340),
maxSize=(250, 898))
self.w.bind("resize", self.windowResized_)
self.isResizing = False
p = 10
w = 160
# options
self.w.options = Group((0, 0, 180, 220))
buttons = {
"checkSelBtn": {
"text": "Check selected glyphs",
"callback": self.checkSel_,
"y": p
},
}
for button, data in buttons.iteritems():
setattr(
self.w.options, button,
Button((p, data["y"], w - 22, 22),
data["text"],
callback=data["callback"],
sizeStyle="small"))
self.w.options.zeroCheck = CheckBox((p, 35, w, 20),
"Ignore zero-width glyphs",
value=True,
sizeStyle="small")
self.w.options.progress = ProgressSpinner((w - 8, 13, 16, 16),
sizeStyle="small")
# results
self.w.results = Group((0, 220, 180, -0))
self.w.results.show(False)
textBoxes = {"stats": -34, "result": -18}
for box, y in textBoxes.iteritems():
setattr(self.w.results, box,
TextBox((p, y, w, 14), "", sizeStyle="small"))
# list and preview
self.w.outputList = List((0, 58, -0, -40), [{
"left glyph": "",
"right glyph": ""
}],
columnDescriptions=[{
"title": "left glyph",
"width": 90
}, {
"title": "right glyph"
}],
showColumnTitles=False,
allowsMultipleSelection=False,
enableDelete=False,
selectionCallback=self.showPair_)
self.w.outputList._setColumnAutoresizing()
self._resizeWindow(False)
self.w.open()
# callbacks
def checkAll_(self, sender=None):
self.check_(useSelection=False)
def checkSel_(self, sender=None):
self.check_(useSelection=True)
def check_(self, useSelection):
self._resizeWindow(enlarge=False)
self.checkFont(useSelection=useSelection,
excludeZeroWidth=self.w.options.zeroCheck.get())
def showPair_(self, sender=None):
try:
index = sender.getSelection()[0]
glyphs = [self.f[gName] for gName in self.touchingPairs[index]]
ActiveFont = self.f._font
EditViewController = ActiveFont.currentTab
if EditViewController is None:
tabText = "/%s/%s" % (glyphs[0].name, glyphs[1].name)
ActiveFont.newTab(tabText)
else:
textStorage = EditViewController.graphicView()
if not hasattr(textStorage,
"replaceCharactersInRange_withString_"
): # compatibility with API change in 2.5
textStorage = EditViewController.graphicView().textStorage(
)
LeftChar = ActiveFont.characterForGlyph_(glyphs[0]._object)
RightChar = ActiveFont.characterForGlyph_(glyphs[1]._object)
if LeftChar != 0 and RightChar != 0:
selection = textStorage.selectedRange()
if selection.length < 2:
selection.length = 2
if selection.location > 0:
selection.location -= 1
NewString = ""
if LeftChar < 0xffff and RightChar < 0xffff:
NewString = "%s%s" % (unichr(LeftChar),
unichr(RightChar))
else:
print("Upper plane codes are not supported yet")
textStorage.replaceCharactersInRange_withString_(
selection, NewString)
selection.length = 0
selection.location += 1
textStorage.setSelectedRange_(selection)
#self.w.preview.set(glyphs)
except IndexError:
pass
# checking
@objc.python_method
def _hasSufficientWidth(self, g):
# to ignore combining accents and the like
if self.excludeZeroWidth:
# also skips 1-unit wide glyphs which many use instead of 0
if g.width < 2 or g._object.subCategory == "Nonspacing":
return False
return True
@objc.python_method
def _trimGlyphList(self, glyphList):
newGlyphList = []
for g in glyphList:
if g.box is not None and self._hasSufficientWidth(g):
newGlyphList.append(g)
return newGlyphList
def windowResized_(self, window):
posSize = self.w.getPosSize()
Height = posSize[3]
if Height > self.closedWindowHeight and self.isResizing is False:
print("set new Height", Height)
NSUserDefaults.standardUserDefaults().setInteger_forKey_(
Height, "ToucheWindowHeight")
self.windowHeight = Height
@objc.python_method
def _resizeWindow(self, enlarge=True):
posSize = self.w.getPosSize()
if enlarge:
self.w.results.show(True)
self.w.outputList.show(True)
targetHeight = self.windowHeight
if targetHeight < 340:
targetHeight = 340
else:
self.w.results.show(False)
self.w.outputList.show(False)
targetHeight = self.closedWindowHeight
self.isResizing = True
self.w.setPosSize((posSize[0], posSize[1], posSize[2], targetHeight))
self.isResizing = False
# ok let's do this
@objc.python_method
def checkFont(self, useSelection=False, excludeZeroWidth=True):
f = CurrentFont()
if f is not None:
# initialize things
self.w.options.progress.start()
time0 = time.time()
self.excludeZeroWidth = excludeZeroWidth
self.f = f
glyphNames = f.selection if useSelection else f.keys()
glyphList = [f[x] for x in glyphNames]
glyphList = self._trimGlyphList(glyphList)
self.touchingPairs = Touche(f).findTouchingPairs(glyphList)
# display output
self.w.results.stats.set("%d glyphs checked" % len(glyphList))
self.w.results.result.set("%d touching pairs found" %
len(self.touchingPairs))
self.w.results.show(True)
outputList = [{
"left glyph": g1,
"right glyph": g2
} for (g1, g2) in self.touchingPairs]
self.w.outputList.set(outputList)
if len(self.touchingPairs) > 0:
self.w.outputList.setSelection([0])
#self.w.preview.setFont(f)
self.w.options.progress.stop()
self._resizeWindow(enlarge=True)
time1 = time.time()
print('Touché: finished checking %d glyphs in %.2f seconds' %
(len(glyphList), time1 - time0))
else:
Message('Touché: Can’t find a font to check')
class AdjustAnchors(BaseWindowController):
def __init__(self):
self.font = CurrentFont()
self.glyph = CurrentGlyph()
self.upm = self.font.info.unitsPerEm
self.rf3 = int(roboFontVersion.split(".")[0]) >= 3
if self.rf3:
self.layer = CurrentLayer()
# key: glyph name -- value: list containing assembled glyphs
self.glyphPreviewCacheDict = {}
# key: anchor name -- value: list of mark glyph names
self.anchorsOnMarksDict = {}
# key: anchor name -- value: list of base glyph names
self.anchorsOnBasesDict = {}
self.CXTanchorsOnBasesDict = {}
# key: mark glyph name -- value: anchor name
# NOTE: It's expected that each mark glyph only has one type of anchor
self.marksDict = {}
self.fillAnchorsAndMarksDicts()
# list of glyph names that will be displayed in the UI list
self.glyphNamesList = []
# list of glyph names selected in the UI list
self.selectedGlyphNamesList = []
# list of the glyph objects that should be inserted
# before and after the accented glyphs
self.extraGlyphsList = []
self.Blue, self.Alpha = 1, 0.6
self.font.naked().addObserver(self, "fontWasModified", "Font.Changed")
addObserver(self, "_fontWillClose", "fontWillClose")
addObserver(self, "_currentFontChanged", "fontResignCurrent")
addObserver(self, "_currentGlyphChanged", "currentGlyphChanged")
addObserver(self, "_drawFill", "draw")
addObserver(self, "_drawFill", "drawInactive")
addObserver(self, "_previewFill", "drawPreview")
# observer for the draw event
addObserver(self, "_drawGlyphs", "draw")
# draw the glyphs when the glyph window is not in focus
addObserver(self, "_drawGlyphs", "drawInactive")
addObserver(self, "_drawGlyphs", "drawPreview")
integerNumFormatter = NSNumberFormatter.alloc().init()
integerNumFormatter.setAllowsFloats_(False)
integerNumFormatter.setGeneratesDecimalNumbers_(False)
intPosMinZeroNumFormatter = NSNumberFormatter.alloc().init()
intPosMinZeroNumFormatter.setAllowsFloats_(False)
intPosMinZeroNumFormatter.setGeneratesDecimalNumbers_(False)
intPosMinZeroNumFormatter.setMinimum_(NSNumber.numberWithInt_(0))
intPosMinOneNumFormatter = NSNumberFormatter.alloc().init()
intPosMinOneNumFormatter.setAllowsFloats_(False)
intPosMinOneNumFormatter.setGeneratesDecimalNumbers_(False)
intPosMinOneNumFormatter.setMinimum_(NSNumber.numberWithInt_(1))
self.textSize = getExtensionDefault("%s.%s" %
(extensionKey, "textSize"))
if not self.textSize:
self.textSize = 150
self.lineHeight = getExtensionDefault("%s.%s" %
(extensionKey, "lineHeight"))
if not self.lineHeight:
self.lineHeight = 200
self.extraSidebearings = getExtensionDefault(
"%s.%s" % (extensionKey, "extraSidebearings"))
if not self.extraSidebearings:
self.extraSidebearings = [0, 0]
self.extraGlyphs = getExtensionDefault("%s.%s" %
(extensionKey, "extraGlyphs"))
if not self.extraGlyphs:
self.extraGlyphs = ''
posSize = getExtensionDefault("%s.%s" % (extensionKey, "posSize"))
if not posSize:
posSize = (100, 100, 1200, 400)
self.calibrateMode = getExtensionDefault(
"%s.%s" % (extensionKey, "calibrateMode"))
if not self.calibrateMode:
self.calibrateMode = False
calibrateModeStrings = getExtensionDefault(
"%s.%s" % (extensionKey, "calibrateModeStrings"))
if not calibrateModeStrings:
calibrateModeStrings = {
'group1.baseInput': 'dotlessi o s',
'group1.markInput': 'dieresis circumflex macron breve caron',
'group2.baseInput': 'I O S',
'group2.markInput': 'dieresis.cap circumflex.cap macron.cap '
'breve.cap caron.cap',
'group3.baseInput': 'I.sc O.sc S.sc',
'group3.markInput': 'dieresis circumflex macron breve caron',
'group4.baseInput': '',
'group4.markInput': '',
}
# -- Window --
self.w = FloatingWindow(posSize, extensionName, minSize=(500, 400))
self.w.fontList = List((10, 10, 190, -41),
self.glyphNamesList,
selectionCallback=self.listSelectionCallback)
if roboFontVersion < '1.7':
# use the full width of the column
self.w.fontList.getNSTableView().sizeToFit()
self.w.fontList.show(not self.calibrateMode)
self.w.lineView = MultiLineView((210, 10, -10, -41),
pointSize=self.textSize,
lineHeight=self.lineHeight,
displayOptions={
"Beam": False,
"displayMode": "Multi Line"
})
self.w.lineView.setFont(self.font)
# -- Calibration Mode --
baseLabel = "Bases"
markLabel = "Marks"
width, height = 190, 140
self.cm = Group((0, 0, 0, 0))
# ---
self.cm.group1 = Group((5, height * 0, width, height - 10))
self.cm.group1.baseLabel = TextBox((0, 0, width, 20), baseLabel)
self.cm.group1.baseInput = EditText(
(0, 21, width, 22),
calibrateModeStrings['group1.baseInput'],
callback=self.updateCalibrateMode,
continuous=False)
self.cm.group1.markLabel = TextBox((0, 50, width, 20), markLabel)
self.cm.group1.markInput = EditText(
(0, 71, width, 44),
calibrateModeStrings['group1.markInput'],
callback=self.updateCalibrateMode,
continuous=False)
self.cm.group1.divider = HorizontalLine((0, -1, -0, 1))
# ---
self.cm.group2 = Group((5, height * 1, width, height - 10))
self.cm.group2.baseLabel = TextBox((0, 0, width, 20), baseLabel)
self.cm.group2.baseInput = EditText(
(0, 21, width, 22),
calibrateModeStrings['group2.baseInput'],
callback=self.updateCalibrateMode,
continuous=False)
self.cm.group2.markLabel = TextBox((0, 50, width, 20), markLabel)
self.cm.group2.markInput = EditText(
(0, 71, width, 44),
calibrateModeStrings['group2.markInput'],
callback=self.updateCalibrateMode,
continuous=False)
self.cm.group2.divider = HorizontalLine((0, -1, -0, 1))
# ---
self.cm.group3 = Group((5, height * 2, width, height - 10))
self.cm.group3.baseLabel = TextBox((0, 0, width, 20), baseLabel)
self.cm.group3.baseInput = EditText(
(0, 21, width, 22),
calibrateModeStrings['group3.baseInput'],
callback=self.updateCalibrateMode,
continuous=False)
self.cm.group3.markLabel = TextBox((0, 50, width, 20), markLabel)
self.cm.group3.markInput = EditText(
(0, 71, width, 44),
calibrateModeStrings['group3.markInput'],
callback=self.updateCalibrateMode,
continuous=False)
self.cm.group3.divider = HorizontalLine((0, -1, -0, 1))
# ---
self.cm.group4 = Group((5, height * 3, width, height - 10))
self.cm.group4.baseLabel = TextBox((0, 0, width, 20), baseLabel)
self.cm.group4.baseInput = EditText(
(0, 21, width, 22),
calibrateModeStrings['group4.baseInput'],
callback=self.updateCalibrateMode,
continuous=False)
self.cm.group4.markLabel = TextBox((0, 50, width, 20), markLabel)
self.cm.group4.markInput = EditText(
(0, 71, width, 44),
calibrateModeStrings['group4.markInput'],
callback=self.updateCalibrateMode,
continuous=False)
# ---
view = DefconAppKitTopAnchoredNSView.alloc().init()
view.addSubview_(self.cm.getNSView())
view.setFrame_(((0, 0), (width + 10, height * 4 - 23)))
self.cm.setPosSize((0, 0, width + 10, height * 4 - 22))
self.w.scrollView = ScrollView((5, 10, width + 10, -41),
view,
drawsBackground=False,
hasHorizontalScroller=False)
self.w.scrollView.getNSScrollView().setBorderType_(NSNoBorder)
# NSScrollElasticityNone
self.w.scrollView.getNSScrollView().setVerticalScrollElasticity_(1)
self.w.scrollView.show(self.calibrateMode)
# -- Footer --
self.w.footer = Group((10, -32, -10, -10))
self.w.footer.calibrateModeCheck = CheckBox(
(0, 0, 200, -0),
"Calibration Mode",
callback=self.calibrateModeCallback,
value=self.calibrateMode)
self.w.footer.textSizeLabel = TextBox((200, 2, 100, -0), "Text Size")
self.w.footer.textSize = EditText((260, 0, 35, -0),
self.textSize,
callback=self.textSizeCallback,
continuous=False,
formatter=intPosMinOneNumFormatter)
self.w.footer.lineHeightLabel = TextBox((310, 2, 100, -0),
"Line Height")
self.w.footer.lineHeight = EditText((385, 0, 35, -0),
self.lineHeight,
callback=self.lineHeightCallback,
continuous=False,
formatter=integerNumFormatter)
self.w.footer.extraSidebearingsLabel = TextBox((436, 2, 180, -0),
"Extra Sidebearings")
self.w.footer.extraSidebearingsChar = TextBox((592, 2, 20, -0), "&")
self.w.footer.extraSidebearingLeft = EditText(
(557, 0, 35, -0),
self.extraSidebearings[0],
callback=self.extraSidebearingsCallback,
continuous=False,
formatter=intPosMinZeroNumFormatter)
self.w.footer.extraSidebearingRight = EditText(
(604, 0, 35, -0),
self.extraSidebearings[1],
callback=self.extraSidebearingsCallback,
continuous=False,
formatter=intPosMinZeroNumFormatter)
self.w.footer.extraGlyphsLabel = TextBox((655, 2, 180, -0),
"Extra Glyphs")
self.w.footer.extraGlyphs = EditText((739, 0, -0, -0),
self.extraGlyphs,
callback=self.extraGlyphsCallback,
continuous=False)
# trigger the initial state and contents of the window
self.extraGlyphsCallback() # calls self.updateExtensionWindow()
self.w.bind("close", self.windowClose)
self.w.open()
self.w.makeKey()
def calibrateModeCallback(self, sender):
self.calibrateMode = not self.calibrateMode
self.w.fontList.show(not sender.get())
self.w.scrollView.show(self.calibrateMode)
self.updateExtensionWindow()
def textSizeCallback(self, sender):
try: # in case the user submits an empty field
self.textSize = int(sender.get())
except Exception: # reset to the previous value
NSBeep()
self.sender.set(self.textSize)
self.w.lineView.setPointSize(self.textSize)
def lineHeightCallback(self, sender):
try:
self.lineHeight = int(sender.get())
except Exception:
NSBeep()
self.sender.set(self.lineHeight)
self.w.lineView.setLineHeight(self.lineHeight)
def extraSidebearingsCallback(self, sender):
left = self.w.footer.extraSidebearingLeft
right = self.w.footer.extraSidebearingRight
try:
self.extraSidebearings = [int(left.get()), int(right.get())]
except Exception:
NSBeep()
left.set(self.extraSidebearings[0])
right.set(self.extraSidebearings[1])
self.extraGlyphsCallback() # calls self.updateExtensionWindow()
def extraGlyphsCallback(self, *sender):
del self.extraGlyphsList[:] # empty the list
self.extraGlyphs = self.w.footer.extraGlyphs.get()
glyphNamesList = self.extraGlyphs.split()
for gName in glyphNamesList:
try:
extraGlyph = self.font[gName]
# must create a new glyph in order to be able to
# increase the sidebearings without modifying the font
newGlyph = RGlyph()
if self.rf3:
newGlyph.layer = self.layer
else:
newGlyph.font = newGlyph.getParent()
# must use deepAppend because the extra glyph may have
# components (which will cause problems to the MultiLineView)
newGlyph = self.deepAppendGlyph(newGlyph, extraGlyph)
newGlyph.width = extraGlyph.width
except Exception:
continue
newGlyph.leftMargin += self.extraSidebearings[0]
newGlyph.rightMargin += self.extraSidebearings[1]
self.extraGlyphsList.append(newGlyph)
self.glyphPreviewCacheDict.clear()
self.updateExtensionWindow()
def windowClose(self, sender):
self.font.naked().removeObserver(self, "Font.Changed")
removeObserver(self, "fontWillClose")
removeObserver(self, "fontResignCurrent")
removeObserver(self, "currentGlyphChanged")
removeObserver(self, "draw")
removeObserver(self, "drawInactive")
removeObserver(self, "drawPreview")
self.saveExtensionDefaults()
def getCalibrateModeStrings(self):
calibrateModeStringsDict = {}
for i in range(1, 5):
group = getattr(self.cm, "group%d" % i)
calibrateModeStringsDict["group%d.baseInput" %
i] = group.baseInput.get()
calibrateModeStringsDict["group%d.markInput" %
i] = group.markInput.get()
return calibrateModeStringsDict
def saveExtensionDefaults(self):
setExtensionDefault("%s.%s" % (extensionKey, "posSize"),
self.w.getPosSize())
setExtensionDefault("%s.%s" % (extensionKey, "textSize"),
self.textSize)
setExtensionDefault("%s.%s" % (extensionKey, "lineHeight"),
self.lineHeight)
setExtensionDefault("%s.%s" % (extensionKey, "extraSidebearings"),
self.extraSidebearings)
setExtensionDefault("%s.%s" % (extensionKey, "extraGlyphs"),
self.extraGlyphs)
setExtensionDefault("%s.%s" % (extensionKey, "calibrateMode"),
self.calibrateMode)
setExtensionDefault("%s.%s" % (extensionKey, "calibrateModeStrings"),
self.getCalibrateModeStrings())
def _previewFill(self, info):
self.Blue, self.Alpha = 0, 1
def _drawFill(self, info):
self.Blue, self.Alpha = 1, 0.6
def _fontWillClose(self, info):
"""
Close the window when the last font is closed
"""
if len(AllFonts()) < 2:
self.windowClose(self)
self.w.close()
def _currentFontChanged(self, info):
self.font.naked().removeObserver(self, "Font.Changed")
self.font = CurrentFont()
self.font.naked().addObserver(self, "fontWasModified", "Font.Changed")
self.w.lineView.setFont(self.font)
self.fillAnchorsAndMarksDicts()
del self.glyphNamesList[:]
del self.selectedGlyphNamesList[:]
self.updateExtensionWindow()
def _currentGlyphChanged(self, info):
self.updateExtensionWindow()
def fontWasModified(self, info):
OutputWindow().clear()
self.fillAnchorsAndMarksDicts()
del self.glyphNamesList[:]
del self.selectedGlyphNamesList[:]
self.updateExtensionWindow()
def deepAppendGlyph(self, glyph, gToAppend, offset=(0, 0)):
if not gToAppend.components:
glyph.appendGlyph(gToAppend, offset)
else:
for component in gToAppend.components:
# avoid traceback in the case where the selected glyph is
# referencing a component whose glyph is not in the font
if component.baseGlyph not in self.font.keys():
print("WARNING: %s is referencing a glyph named %s, which "
"does not exist in the font." %
(self.font.selection[0], component.baseGlyph))
continue
compGlyph = self.font[component.baseGlyph].copy()
# handle component transformations
componentTransformation = component.transformation
# when undoing a paste anchor or a delete anchor action,
# RoboFont returns component.transformation as a list instead
# of a tuple
if type(componentTransformation) is list:
componentTransformation = tuple(componentTransformation)
# if component is skewed and/or is shifted
if componentTransformation != (1, 0, 0, 1, 0, 0):
matrix = componentTransformation[0:4]
if matrix != (1, 0, 0, 1): # if component is skewed
# ignore the original component's shifting values
transformObj = Identity.transform(matrix + (0, 0))
compGlyph.transform(transformObj)
# add the two tuples of offset
glyph.appendGlyph(
compGlyph, tuple(map(sum, zip(component.offset, offset))))
for contour in gToAppend:
glyph.appendContour(contour, offset)
# if the assembled glyph still has components, recursively
# remove and replace them 1-by-1 by the glyphs they reference
if glyph.components:
nestedComponent = glyph.components[-1] # start from the end
glyph.removeComponent(nestedComponent)
glyph = self.deepAppendGlyph(glyph,
self.font[nestedComponent.baseGlyph],
nestedComponent.offset)
return glyph
def updateCalibrateMode(self, *sender):
glyphsList = []
newLine = self.w.lineView.createNewLineGlyph()
# cycle thru the UI Groups and collect the strings
for i in range(1, 5):
group = getattr(self.cm, "group%d" % i)
baseGlyphsNamesList = group.baseInput.get().split()
markGlyphsNamesList = group.markInput.get().split()
# iterate thru the base+mark combinations
for gBaseName, gMarkName in product(baseGlyphsNamesList,
markGlyphsNamesList):
newGlyph = RGlyph()
if self.rf3:
newGlyph.layer = self.layer
else:
newGlyph.font = newGlyph.getParent()
# skip invalid glyph names
try:
baseGlyph = self.font[gBaseName]
markGlyph = self.font[gMarkName]
except Exception:
continue
# append base glyph
newGlyph = self.deepAppendGlyph(newGlyph, baseGlyph)
# append mark glyph
newGlyph = self.deepAppendGlyph(
newGlyph, markGlyph,
self.getAnchorOffsets(baseGlyph, markGlyph))
# set the advanced width
dfltSidebearings = self.upm * .05 # 5% of UPM
newGlyph.leftMargin = (dfltSidebearings +
self.extraSidebearings[0])
newGlyph.rightMargin = (dfltSidebearings +
self.extraSidebearings[1])
# append the assembled glyph to the list
glyphsList.extend(self.extraGlyphsList)
glyphsList.append(newGlyph)
# add line break, if both input fields have content
if baseGlyphsNamesList and markGlyphsNamesList:
glyphsList.extend(self.extraGlyphsList)
glyphsList.append(newLine)
# update the contents of the MultiLineView
self.w.lineView.set(glyphsList)
def updateExtensionWindow(self):
if self.calibrateMode:
self.updateCalibrateMode()
return
# NOTE: CurrentGlyph() will return zero (its length),
# so "is not None" is necessary
if CurrentGlyph() is not None:
self.glyph = CurrentGlyph()
self.glyphNamesList = self.makeGlyphNamesList(self.glyph)
self.updateListView()
currentGlyphName = self.glyph.name
# base glyph + accent combinations preview
# first check if there's a cached glyph
if currentGlyphName in self.glyphPreviewCacheDict:
self.w.lineView.set(
self.glyphPreviewCacheDict[currentGlyphName])
# assemble the glyphs
else:
glyphsList = []
for glyphNameInUIList in self.glyphNamesList:
# trim the contextual portion of the UI glyph name
# and keep track of it
if CONTEXTUAL_ANCHOR_TAG in glyphNameInUIList:
cxtTagIndex = glyphNameInUIList.find(
CONTEXTUAL_ANCHOR_TAG)
glyphNameCXTportion = glyphNameInUIList[cxtTagIndex:]
# this line must be last!
glyphNameInUIList = glyphNameInUIList[:cxtTagIndex]
else:
glyphNameCXTportion = ''
newGlyph = RGlyph()
if self.rf3:
newGlyph.layer = self.layer
else:
newGlyph.font = newGlyph.getParent()
# the glyph in the UI list is a mark
if glyphNameInUIList in self.marksDict:
markGlyph = self.font[glyphNameInUIList]
# append base glyph
newGlyph = self.deepAppendGlyph(newGlyph, self.glyph)
# append mark glyph
newGlyph = self.deepAppendGlyph(
newGlyph, markGlyph,
self.getAnchorOffsets(self.glyph, markGlyph,
glyphNameCXTportion))
# set the advanced width
# combining marks or other glyphs with
# a small advanced width
if self.glyph.width < 10:
newGlyph.leftMargin = self.upm * .05 # 5% of UPM
newGlyph.rightMargin = newGlyph.leftMargin
else:
newGlyph.width = self.glyph.width
# the glyph in the UI list is a base
else:
baseGlyph = self.font[glyphNameInUIList]
# append base glyph
newGlyph = self.deepAppendGlyph(newGlyph, baseGlyph)
# append mark glyph
newGlyph = self.deepAppendGlyph(
newGlyph, self.glyph,
self.getAnchorOffsets(baseGlyph, self.glyph))
# set the advanced width
# combining marks or other glyphs with
# a small advanced width
if self.glyph.width < 10:
newGlyph.leftMargin = self.upm * .05
newGlyph.rightMargin = newGlyph.leftMargin
else:
newGlyph.width = baseGlyph.width
# pad the new glyph if it has too much overhang
if newGlyph.leftMargin < self.upm * .15:
newGlyph.leftMargin = self.upm * .05
if newGlyph.rightMargin < self.upm * .15:
newGlyph.rightMargin = self.upm * .05
# add extra sidebearings
newGlyph.leftMargin += self.extraSidebearings[0]
newGlyph.rightMargin += self.extraSidebearings[1]
# one last check for making sure the new glyph
# can be displayed
if not newGlyph.components:
glyphsList.extend(self.extraGlyphsList)
glyphsList.append(newGlyph)
else:
print("Combination with mark glyph %s can't be "
"previewed because it contains component %s." %
(glyphNameInUIList + glyphNameCXTportion,
newGlyph.components[0].baseGlyph))
glyphsList.extend(self.extraGlyphsList)
self.w.lineView.set(glyphsList)
# add to the cache
self.glyphPreviewCacheDict[currentGlyphName] = glyphsList
else:
self.w.lineView.set([])
def listSelectionCallback(self, sender):
selectedGlyphNamesList = []
for index in sender.getSelection():
selectedGlyphNamesList.append(self.glyphNamesList[index])
self.selectedGlyphNamesList = selectedGlyphNamesList
self.updateGlyphView()
def updateGlyphView(self):
UpdateCurrentGlyphView()
def fillAnchorsAndMarksDicts(self):
# reset all the dicts
self.glyphPreviewCacheDict.clear()
self.anchorsOnMarksDict.clear()
self.anchorsOnBasesDict.clear()
self.CXTanchorsOnBasesDict.clear()
self.marksDict.clear()
markGlyphsWithMoreThanOneAnchorTypeList = []
for glyphName in self.font.glyphOrder:
glyphAnchorsList = self.font[glyphName].anchors
for anchor in glyphAnchorsList:
if anchor.name[0] == '_':
anchorName = anchor.name[1:]
# add to AnchorsOnMarks dictionary
if anchorName not in self.anchorsOnMarksDict:
self.anchorsOnMarksDict[anchorName] = [glyphName]
else:
tempList = self.anchorsOnMarksDict[anchorName]
tempList.append(glyphName)
self.anchorsOnMarksDict[anchorName] = tempList
# add to Marks dictionary
if glyphName not in self.marksDict:
self.marksDict[glyphName] = anchorName
else:
if (glyphName not in
markGlyphsWithMoreThanOneAnchorTypeList):
markGlyphsWithMoreThanOneAnchorTypeList.append(
glyphName)
else:
anchorName = anchor.name
if CONTEXTUAL_ANCHOR_TAG in anchorName:
# add to AnchorsOnBases dictionary
if anchorName not in self.CXTanchorsOnBasesDict:
self.CXTanchorsOnBasesDict[anchorName] = [
glyphName
]
else:
tempList = self.CXTanchorsOnBasesDict[anchorName]
tempList.append(glyphName)
self.CXTanchorsOnBasesDict[anchorName] = tempList
else:
# add to AnchorsOnBases dictionary
if anchorName not in self.anchorsOnBasesDict:
self.anchorsOnBasesDict[anchorName] = [glyphName]
else:
tempList = self.anchorsOnBasesDict[anchorName]
tempList.append(glyphName)
self.anchorsOnBasesDict[anchorName] = tempList
if markGlyphsWithMoreThanOneAnchorTypeList:
for glyphName in markGlyphsWithMoreThanOneAnchorTypeList:
print("ERROR: Glyph %s has more than one type of anchor." %
glyphName)
def makeGlyphNamesList(self, glyph):
glyphNamesList = []
markGlyphIsAbleToBeBase = False
# NOTE: "if glyph" will return zero (its length),
# so "is not None" is necessary
if glyph is not None:
# assemble the list for the UI list
for anchor in glyph.anchors:
anchorName = anchor.name
# the glyph selected is a base
if anchorName in self.anchorsOnMarksDict:
glyphNamesList.extend(self.anchorsOnMarksDict[anchorName])
# the glyph selected is a mark
# skips the leading underscore
elif anchorName[1:] in self.anchorsOnBasesDict:
glyphNamesList.extend(
self.anchorsOnBasesDict[anchorName[1:]])
# the glyph selected is a base
elif anchorName[0] != '_' and (anchorName
in self.CXTanchorsOnBasesDict):
cxtTagIndex = anchorName.find(CONTEXTUAL_ANCHOR_TAG)
anchorNameNOTCXTportion = anchorName[:cxtTagIndex]
anchorNameCXTportion = anchorName[cxtTagIndex:]
# XXX here only the first mark glyph that has an anchor of
# the kind 'anchorNameNOTCXTportion' is considered.
# This is probably harmless, but...
glyphName = '%s%s' % (
self.anchorsOnMarksDict[anchorNameNOTCXTportion][0],
anchorNameCXTportion)
glyphNamesList.append(glyphName)
# for mark glyphs, test if they're able to get
# other mark glyphs attached to them.
# this will (correctly) prevent the UI list from including
# glyph names that cannot be displayed with the current glyph
if glyph.name in self.marksDict:
for anchor in glyph.anchors:
# the current mark glyph has anchors that
# allow it to be a base for other marks
if anchor.name[0] != '_':
markGlyphIsAbleToBeBase = True
break
# remove marks from the glyph list if the
# current mark glyph can't work as a base
if not markGlyphIsAbleToBeBase:
# iterate from the end of the list
for glyphName in glyphNamesList[::-1]:
if glyphName in self.marksDict:
glyphNamesList.remove(glyphName)
glyphNamesList.sort()
return glyphNamesList
def updateListView(self):
self.w.fontList.set(self.glyphNamesList)
def getAnchorOffsets(self,
canvasGlyph,
glyphToDraw,
anchorNameCXTportion=''):
# the current glyph is a mark
if canvasGlyph.name in self.marksDict:
# glyphToDraw is also a mark (mark-to-mark case)
if glyphToDraw.name in self.marksDict:
# pick the (mark glyph) anchor to draw on
for anchor in canvasGlyph.anchors:
if anchor.name[0] != '_':
anchorName = anchor.name
markAnchor = anchor
break
# pick the (base glyph) anchor to draw on
for anchor in glyphToDraw.anchors:
try:
if anchor.name == '_' + anchorName:
baseAnchor = anchor
break
except UnboundLocalError:
continue
# glyphToDraw is not a mark
else:
# pick the (mark glyph) anchor to draw on
for anchor in canvasGlyph.anchors:
if anchor.name[0] == '_':
anchorName = anchor.name[1:]
markAnchor = anchor
break
# pick the (base glyph) anchor to draw on
for anchor in glyphToDraw.anchors:
try:
if anchor.name == anchorName:
baseAnchor = anchor
break
except UnboundLocalError:
continue
try:
offsetX = markAnchor.x - baseAnchor.x
offsetY = markAnchor.y - baseAnchor.y
except UnboundLocalError:
offsetX = 0
offsetY = 0
# the current glyph is a base
else:
try:
anchorName = self.marksDict[glyphToDraw.name]
except KeyError:
anchorName = None
if anchorName:
# pick the (base glyph) anchor to draw on
for anchor in canvasGlyph.anchors:
if anchor.name == anchorName + anchorNameCXTportion:
baseAnchor = anchor
break
# pick the (mark glyph) anchor to draw on
for anchor in glyphToDraw.anchors:
if anchor.name == '_' + anchorName:
markAnchor = anchor
break
try:
offsetX = baseAnchor.x - markAnchor.x
offsetY = baseAnchor.y - markAnchor.y
except UnboundLocalError:
offsetX = 0
offsetY = 0
return (offsetX, offsetY)
def _drawGlyphs(self, info):
""" draw stuff in the glyph window view """
translateBefore = (0, 0)
for glyphName in self.selectedGlyphNamesList:
# trim the contextual portion of the UI glyph name
# and keep track of it
if CONTEXTUAL_ANCHOR_TAG in glyphName:
cxtTagIndex = glyphName.find(CONTEXTUAL_ANCHOR_TAG)
glyphNameCXTportion = glyphName[cxtTagIndex:]
glyphName = glyphName[:cxtTagIndex] # this line must be last!
else:
glyphNameCXTportion = ''
glyphToDraw = self.font[glyphName]
# determine the offset of the anchors
offset = self.getAnchorOffsets(self.glyph, glyphToDraw,
glyphNameCXTportion)
# set the offset of the drawing
translate(offset[0] - translateBefore[0],
offset[1] - translateBefore[1])
# record the shift amounts (these are needed for resetting the
# drawing position when more than one mark is selected on the list)
translateBefore = offset
# set the fill & stroke
fill(0, 0, self.Blue, self.Alpha)
strokeWidth(None)
# draw it
mojoPen = MojoDrawingToolsPen(glyphToDraw, self.font)
glyphToDraw.draw(mojoPen)
mojoPen.draw()
class ToucheTool():
def __init__(self):
NSUserDefaults.standardUserDefaults().registerDefaults_({"ToucheWindowHeight":340})
self.windowHeight = NSUserDefaults.standardUserDefaults().integerForKey_("ToucheWindowHeight")
self.minWindowHeight = 340
if self.windowHeight < self.minWindowHeight:
self.windowHeight = self.minWindowHeight
self.closedWindowHeight = 100
self.w = FloatingWindow((180, self.windowHeight), u'Touché!', minSize=(180,340), maxSize=(250,898))
self.w.bind("resize", self.windowResized)
self.isResizing = False
p = 10
w = 160
# options
self.w.options = Group((0, 0, 180, 220))
buttons = {
"checkSelBtn": {"text": "Check selected glyphs", "callback": self.checkSel, "y": p},
}
for button, data in buttons.iteritems():
setattr(self.w.options, button,
Button((p, data["y"], w - 22, 22), data["text"], callback=data["callback"], sizeStyle="small"))
self.w.options.zeroCheck = CheckBox((p, 35, w, 20), "Ignore zero-width glyphs", value=True, sizeStyle="small")
self.w.options.progress = ProgressSpinner((w - 8, 13, 16, 16), sizeStyle="small")
# results
self.w.results = Group((0, 220, 180, -0))
self.w.results.show(False)
textBoxes = {"stats": -34, "result": -18}
for box, y in textBoxes.iteritems():
setattr(self.w.results, box, TextBox((p, y, w, 14), "", sizeStyle="small"))
# list and preview
self.w.outputList = List((0,58,-0,-40),
[{"left glyph": "", "right glyph": ""}], columnDescriptions=[{"title": "left glyph", "width": 90}, {"title": "right glyph"}],
showColumnTitles=False, allowsMultipleSelection=False, enableDelete=False, selectionCallback=self.showPair)
self.w.outputList._setColumnAutoresizing()
self._resizeWindow(False)
self.w.open()
# callbacks
def checkAll(self, sender=None):
self.check(useSelection=False)
def checkSel(self, sender=None):
self.check(useSelection=True)
def check(self, useSelection):
self._resizeWindow(enlarge=False)
self.checkFont(useSelection=useSelection, excludeZeroWidth=self.w.options.zeroCheck.get())
def showPair(self, sender=None):
try:
index = sender.getSelection()[0]
glyphs = [self.f[gName] for gName in self.touchingPairs[index]]
ActiveFont = self.f._font
EditViewController = ActiveFont.currentTab
if EditViewController is None:
tabText = "/%s/%s" %(glyphs[0].name, glyphs[1].name)
ActiveFont.newTab(tabText)
else:
textStorage = EditViewController.graphicView()
if not hasattr(textStorage, "replaceCharactersInRange_withString_"): # compatibility with API change in 2.5
textStorage = EditViewController.graphicView().textStorage()
LeftChar = ActiveFont.characterForGlyph_(glyphs[0]._object)
RightChar = ActiveFont.characterForGlyph_(glyphs[1]._object)
if LeftChar != 0 and RightChar != 0:
selection = textStorage.selectedRange()
if selection.length < 2:
selection.length = 2
if selection.location > 0:
selection.location -= 1
NewString = ""
if LeftChar < 0xffff and RightChar < 0xffff:
NewString = u"%s%s" % (unichr(LeftChar), unichr(RightChar))
else:
print "Upper plane codes are not supported yet"
textStorage.replaceCharactersInRange_withString_(selection, NewString)
selection.length = 0
selection.location += 1
textStorage.setSelectedRange_(selection)
#self.w.preview.set(glyphs)
except IndexError:
pass
# checking
def _hasSufficientWidth(self, g):
# to ignore combining accents and the like
if self.excludeZeroWidth:
# also skips 1-unit wide glyphs which many use instead of 0
if g.width < 2 or g._object.subCategory == "Nonspacing":
return False
return True
def _trimGlyphList(self, glyphList):
newGlyphList = []
for g in glyphList:
if g.box is not None and self._hasSufficientWidth(g):
newGlyphList.append(g)
return newGlyphList
def windowResized(self, window):
posSize = self.w.getPosSize()
Height = posSize[3]
if Height > self.closedWindowHeight and self.isResizing is False:
print "set new Height", Height
NSUserDefaults.standardUserDefaults().setInteger_forKey_(Height, "ToucheWindowHeight")
self.windowHeight = Height
def _resizeWindow(self, enlarge=True):
posSize = self.w.getPosSize()
if enlarge:
self.w.results.show(True)
self.w.outputList.show(True)
targetHeight = self.windowHeight
if targetHeight < 340:
targetHeight = 340
else:
self.w.results.show(False)
self.w.outputList.show(False)
targetHeight = self.closedWindowHeight
self.isResizing = True
self.w.setPosSize((posSize[0], posSize[1], posSize[2], targetHeight))
self.isResizing = False
# ok let's do this
def checkFont(self, useSelection=False, excludeZeroWidth=True):
f = CurrentFont()
if f is not None:
# initialize things
self.w.options.progress.start()
time0 = time.time()
self.excludeZeroWidth = excludeZeroWidth
self.f = f
glyphNames = f.selection if useSelection else f.keys()
glyphList = [f[x] for x in glyphNames]
glyphList = self._trimGlyphList(glyphList)
self.touchingPairs = Touche(f).findTouchingPairs(glyphList)
# display output
self.w.results.stats.set("%d glyphs checked" % len(glyphList))
self.w.results.result.set("%d touching pairs found" % len(self.touchingPairs))
self.w.results.show(True)
outputList = [{"left glyph": g1, "right glyph": g2} for (g1, g2) in self.touchingPairs]
self.w.outputList.set(outputList)
if len(self.touchingPairs) > 0:
self.w.outputList.setSelection([0])
#self.w.preview.setFont(f)
self.w.options.progress.stop()
self._resizeWindow(enlarge=True)
time1 = time.time()
print u'Touché: finished checking %d glyphs in %.2f seconds' % (len(glyphList), time1-time0)
else:
Message(u'Touché: Can’t find a font to check')
class Adhesiontext(BaseWindowController):
def __init__(self):
flushAlign = 76
firstRowY = 12
rowOffsetY = 30
firstCheckY = 135
checkOffsetY = 27
rightMarginX = -12
self.windowWidth = 410
self.windowHeightWithoutOptions = 45
self.windowHeightWithOptions = 280
self.scriptIsRTL = False
windowPos = getExtensionDefault("%s.%s" % (extensionKey, "windowPos"))
if not windowPos:
windowPos = (100, 100)
self.optionsVisible = getExtensionDefault("%s.%s" % (extensionKey, "optionsVisible"))
if self.optionsVisible:
optionsButtonSign = '-'
windowHeight = self.windowHeightWithOptions
else:
self.optionsVisible = False # needs to be set because the first time the extension runs self.optionsVisible will be None
optionsButtonSign = '+'
windowHeight = self.windowHeightWithoutOptions
self.chars = getExtensionDefault("%s.%s" % (extensionKey, "chars"))
if not self.chars:
self.chars = ''
self.sliderValue = getExtensionDefault("%s.%s" % (extensionKey, "sliderValue"))
if not self.sliderValue:
self.sliderValue = 25
self.scriptsIndex = getExtensionDefault("%s.%s" % (extensionKey, "scriptsIndex"))
if not self.scriptsIndex:
self.scriptsIndex = 0
self.langsIndex = getExtensionDefault("%s.%s" % (extensionKey, "langsIndex"))
if not self.langsIndex:
self.langsIndex = 0
self.w = FloatingWindow((windowPos[0], windowPos[1], self.windowWidth, windowHeight), "adhesiontext")
# 1st row
self.w.labelChars = TextBox((10, firstRowY, flushAlign, 20), "Characters:", alignment="right")
self.w.chars = EditText((flushAlign +15, firstRowY -1, 199, 22), self.chars, callback=self.charsCallback)
self.w.button = Button((300, firstRowY, 68, 20), "Get text", callback=self.buttonCallback)
self.w.spinner = FixedSpinner((325, firstRowY, 20, 20), displayWhenStopped=False)
self.w.optionsButton = SquareButton((378, firstRowY +1, 18, 18), optionsButtonSign, sizeStyle="small", callback=self.optionsCallback)
# set the initial state of the button according to the content of the chars EditText
if len(self.w.chars.get()): self.w.button.enable(True)
else: self.w.button.enable(False)
# keep track of the content of chars EditText
self.previousChars = self.w.chars.get()
# 2nd row
self.w.labelWords = TextBox((10, firstRowY + rowOffsetY, flushAlign, 20), "Words:", alignment="right")
self.w.wordCount = TextBox((flushAlign +12, firstRowY + rowOffsetY, 40, 20), alignment="left")
self.w.slider = Slider((flushAlign +47, firstRowY + rowOffsetY +1, 165, 20), value=self.sliderValue, minValue=5, maxValue=200, callback=self.sliderCallback)
# set the initial wordCount value according to the position of the slider
self.w.wordCount.set(int(self.w.slider.get()))
# 3rd row
self.w.labelScripts = TextBox((10, firstRowY + rowOffsetY *2, flushAlign, 20), "Script:", alignment="right")
self.w.scriptsPopup = PopUpButton((flushAlign +15, firstRowY + rowOffsetY *2, 150, 20), scriptsNameList, callback=self.scriptsCallback)
self.w.scriptsPopup.set(self.scriptsIndex)
# 4th row
self.w.labelLangs = TextBox((10, firstRowY + rowOffsetY *3, flushAlign, 20), "Language:", alignment="right")
self.w.langsPopup = PopUpButton((flushAlign +15, firstRowY + rowOffsetY *3, 150, 20), [])
# set the initial list of languages according to the script value
self.w.langsPopup.setItems(langsNameDict[scriptsNameList[self.w.scriptsPopup.get()]])
self.w.langsPopup.set(self.langsIndex)
self.punctCheck = getExtensionDefault("%s.%s" % (extensionKey, "punctCheck"))
if not self.punctCheck:
self.punctCheck = 0
self.figsCheck = getExtensionDefault("%s.%s" % (extensionKey, "figsCheck"))
if not self.figsCheck:
self.figsCheck = 0
self.figsPopup = getExtensionDefault("%s.%s" % (extensionKey, "figsPopup"))
if not self.figsPopup:
self.figsPopup = 0
self.trimCheck = getExtensionDefault("%s.%s" % (extensionKey, "trimCheck"))
if not self.trimCheck:
self.trimCheck = 0
self.caseCheck = getExtensionDefault("%s.%s" % (extensionKey, "caseCheck"))
if not self.caseCheck:
self.caseCheck = 0
self.casingCheck = getExtensionDefault("%s.%s" % (extensionKey, "casingCheck"))
if not self.casingCheck:
self.casingCheck = 0
self.casingPopup = getExtensionDefault("%s.%s" % (extensionKey, "casingPopup"))
if not self.casingPopup:
self.casingPopup = 0
# 1st checkbox
self.w.punctCheck = CheckBox((flushAlign +15, firstCheckY, 130, 20), "Add punctuation")
self.w.punctCheck.set(self.punctCheck)
# 2nd checkbox
self.w.figsCheck = CheckBox((flushAlign +15, firstCheckY + checkOffsetY, 120, 20), "Insert numbers", callback=self.figsCallback)
self.w.figsCheck.set(self.figsCheck)
self.w.figsPopup = PopUpButton((210, firstCheckY + checkOffsetY, 90, 20), figOptionsList)
self.w.figsPopup.set(self.figsPopup)
# enable or disable the figure options PopUp depending on the figures CheckBox
if scriptsNameList[self.w.scriptsPopup.get()] in enableFigOptionList:
self.w.figsPopup.show(True)
if self.w.figsCheck.get():
self.w.figsPopup.enable(True)
else:
self.w.figsPopup.enable(False)
else:
self.w.figsPopup.show(False)
# 3rd checkbox
self.w.trimCheck = CheckBoxPlus((flushAlign +15, firstCheckY + checkOffsetY *2, 120, 20), "Trim accents")
self.w.trimCheck.set(self.trimCheck)
if scriptsNameList[self.w.scriptsPopup.get()] in enableTrimCheckList:
self.w.trimCheck.enable(True)
else:
self.w.trimCheck.enable(False)
# 4th checkbox
self.w.caseCheck = CheckBoxPlus((flushAlign +15, firstCheckY + checkOffsetY *3, 120, 20), "Ignore casing")
self.w.caseCheck.set(self.caseCheck)
if scriptsNameList[self.w.scriptsPopup.get()] in enableCaseCheckList:
self.w.caseCheck.enable(True)
else:
self.w.caseCheck.enable(False)
# 5th checkbox
self.w.casingCheck = CheckBoxPlus((flushAlign +15, firstCheckY + checkOffsetY *4, 115, 20), "Change casing", callback=self.casingCallback)
self.w.casingCheck.set(self.casingCheck)
if scriptsNameList[self.w.scriptsPopup.get()] in enableCaseCheckList:
self.w.casingCheck.enable(True)
else:
self.w.casingCheck.enable(False)
self.w.casingPopup = PopUpButton((210, firstCheckY + checkOffsetY *4, 90, 20), casingNameList)
self.w.casingPopup.set(self.casingPopup)
# enable or disable the casing PopUp depending on the casing CheckBox
if self.w.casingCheck.get() and self.w.casingCheck.isEnable():
self.w.casingPopup.enable(True)
else:
self.w.casingPopup.enable(False)
self.nsTextField = self.w.chars.getNSTextField()
self.w.setDefaultButton(self.w.button)
self.w.bind("close", self.windowClose)
self.w.open()
self.w.makeKey()
def windowClose(self, sender):
self.saveExtensionDefaults()
def saveExtensionDefaults(self):
setExtensionDefault("%s.%s" % (extensionKey, "windowPos"), self.w.getPosSize()[0:2])
setExtensionDefault("%s.%s" % (extensionKey, "optionsVisible"), self.optionsVisible)
setExtensionDefault("%s.%s" % (extensionKey, "chars"), self.w.chars.get())
setExtensionDefault("%s.%s" % (extensionKey, "sliderValue"), int(self.w.slider.get()))
setExtensionDefault("%s.%s" % (extensionKey, "scriptsIndex"), int(self.w.scriptsPopup.get()))
setExtensionDefault("%s.%s" % (extensionKey, "langsIndex"), int(self.w.langsPopup.get()))
setExtensionDefault("%s.%s" % (extensionKey, "punctCheck"), self.w.punctCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "figsCheck"), self.w.figsCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "figsPopup"), self.w.figsPopup.get())
setExtensionDefault("%s.%s" % (extensionKey, "trimCheck"), self.w.trimCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "caseCheck"), self.w.caseCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "casingCheck"), self.w.casingCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "casingPopup"), self.w.casingPopup.get())
def buttonCallback(self, sender):
sender.enable(False)
self.w.spinner.start()
self.getText()
self.w.spinner.stop()
sender.enable(True)
def optionsCallback(self, sender):
sign = sender.getTitle()
if sign == "+":
sender.setTitle("-")
self.w.resize(self.windowWidth, self.windowHeightWithOptions, animate=True)
self.optionsVisible = True
else:
sender.setTitle("+")
self.w.resize(self.windowWidth, self.windowHeightWithoutOptions, animate=True)
self.optionsVisible = False
def charsCallback(self, sender):
charsContent = sender.get()
if len(charsContent):
self.w.button.enable(True)
nsTextView = self.nsTextField.currentEditor() # NOTE: the field editor is only available when NSTextField is in editing mode.
# when only one glyph is selected and copied, the contents of the clipboard are the glyph's XML
# instead of its unicode character or its name; therefore, post-process the pasted content.
if xmlHeader in charsContent:
caretIndex = charsContent.index(xmlHeader)
codepointString = re_glyphUnicode.search(charsContent)
glyphName = re_glyphName.search(charsContent)
if codepointString:
replacement = unichr(eval('0x' + codepointString.group(1)))
elif glyphName:
replacement = '/' + glyphName.group(1)
else:
replacement = ''
# replace the glyph's XML by its unicode character or its name
self.w.chars.set(re_glyph.sub(replacement, charsContent))
# restore the location of the caret
location = caretIndex + len(replacement)
nsTextView.setSelectedRange_((location, 0))
# update the variable
charsContent = sender.get()
caretIndex = nsTextView.selectedRanges()[0].rangeValue().location
# Limit the number of characters
numeralWasFound = self.stringHasNumeral(charsContent)
if len(charsContent) > maxChars or numeralWasFound:
NSBeep()
if numeralWasFound:
self.showMessage("Sorry, numerals are not allowed.", "")
else:
self.showMessage("You've reached the maximum \rnumber of characters.", "The limit is %d." % maxChars)
# restore the content of chars EditText to the previous string
sender.set(self.previousChars)
# restore the focus on the chars EditText and restore the location of the caret
caretIndexAdjust = len(self.previousChars) - len(charsContent)
self.w.getNSWindow().makeFirstResponder_(self.nsTextField)
nsTextView.setSelectedRange_((caretIndex + caretIndexAdjust, 0))
# update the stored string
self.previousChars = sender.get()
else:
self.w.button.enable(False)
def sliderCallback(self, sender):
self.w.wordCount.set(int(sender.get()))
def scriptsCallback(self, sender):
self.w.langsPopup.setItems(langsNameDict[scriptsNameList[sender.get()]])
# toggle RTL/LTR
if scriptsNameList[sender.get()] in rightToLeftList:
self.scriptIsRTL = True
self.nsTextField.setBaseWritingDirection_(NSWritingDirectionRightToLeft)
self.nsTextField.setAlignment_(NSRightTextAlignment)
else:
self.scriptIsRTL = False
self.nsTextField.setBaseWritingDirection_(NSWritingDirectionLeftToRight)
self.nsTextField.setAlignment_(NSLeftTextAlignment)
# restore the focus on the chars EditText
self.w.getNSWindow().makeFirstResponder_(self.nsTextField)
# toggle figsPopup
if scriptsNameList[sender.get()] in enableFigOptionList:
self.w.figsPopup.show(True)
if self.w.figsCheck.get():
self.w.figsPopup.enable(True)
else:
self.w.figsPopup.enable(False)
else:
self.w.figsPopup.show(False)
# toggle trimCheck
if scriptsNameList[sender.get()] in enableTrimCheckList:
self.w.trimCheck.enable(True)
else:
self.w.trimCheck.enable(False)
# toggle caseCheck and casingCheck
if scriptsNameList[sender.get()] in enableCaseCheckList:
self.w.caseCheck.enable(True)
self.w.casingCheck.enable(True)
if self.w.casingCheck.get():
self.w.casingPopup.enable(True)
else:
self.w.caseCheck.enable(False)
self.w.casingCheck.enable(False)
self.w.casingPopup.enable(False)
def figsCallback(self, sender):
if sender.get():
self.w.figsPopup.enable(True)
else:
self.w.figsPopup.enable(False)
def casingCallback(self, sender):
if sender.get():
self.w.casingPopup.enable(True)
else:
self.w.casingPopup.enable(False)
def stringHasNumeral(self, string):
if re_numeral.search(string):
return True
return False
def isConnected(self):
try:
urlopen(url, timeout=3)
return True
except URLError:
pass
return False
def getText(self):
if CurrentFont() is None:
NSBeep()
self.showMessage("Open a font first.", "")
return
if not self.isConnected():
NSBeep()
self.showMessage("Required internet connection not found.", "")
return
values = {'chars' : self.w.chars.get().encode('utf-8'),
'script' : scriptsTagDict[scriptsNameList[self.w.scriptsPopup.get()]],
'tb' : langsTagDict[langsNameDict[scriptsNameList[self.w.scriptsPopup.get()]][self.w.langsPopup.get()]] }
if self.w.punctCheck.get():
values['punct'] = True
if self.w.figsCheck.get():
values['figs'] = True
if self.w.figsPopup.isVisible():
figsOptTagsList = ["dflt", "locl"]
values['figsOpt'] = figsOptTagsList[self.w.figsPopup.get()]
if self.w.trimCheck.get() and self.w.trimCheck.isEnable():
values['trim'] = True
if self.w.caseCheck.get() and self.w.caseCheck.isEnable():
values['case'] = True
if self.w.casingCheck.get() and self.w.casingCheck.isEnable():
values['casing'] = casingNameList[self.w.casingPopup.get()].lower()
data = urlencode(values)
data = data.encode('utf-8')
print(data)
request = Request(url, data)
response = urlopen(request)
text = response.read()
textU = unicode(text, 'utf-8')
if (msgStr in textU):
textU = textU.replace(msgStr, "")
NSBeep()
self.showMessage(textU, "")
return
elif (wrnStr in textU):
resultIndex = textU.find(rsltStr)
secmsgIndex = textU.find(sndStr)
frstmsgU = textU[:secmsgIndex].replace(wrnStr, "")
scndmsgU = textU[secmsgIndex:resultIndex].replace(sndStr, "")
textU = textU[resultIndex:].replace(rsltStr, "")
NSBeep()
self.showMessage(frstmsgU, scndmsgU)
textList = textU.split()
trimmedText = ' '.join(textList[:int(self.w.slider.get())])
if CurrentSpaceCenter() is None:
OpenSpaceCenter(CurrentFont(), newWindow=False)
sp = CurrentSpaceCenter()
print(trimmedText)
sp.setRaw(trimmedText)
# Toggle RTL-LTR
try:
sp.setLeftToRight(not self.scriptIsRTL)
sp.setInputWritingDirection('Right to Left' if self.scriptIsRTL else 'Left to Right')
except AttributeError:
pass
return
class Script(object):
def __init__(self):
self.valuesPrefsKey = prefsKey + ".delta." + basename(
Glyphs.font.filepath)
# UI metrics
spacing = 8
height = 22
# calculate window height
minWinSize = (220,
120 + (len(Glyphs.font.masters) * (height + spacing)))
# create UI window
self.w = FloatingWindow(minWinSize,
"Adjust sidebearings",
minSize=minWinSize,
maxSize=(500, 500),
autosaveName=prefsKey + ".win")
# layout UI controls
y = 16
self.w.label = TextBox((16, y, -16, height),
"Sidebearing delta adjustment:")
y += height + spacing
inputWidth = 64
for master in Glyphs.font.masters:
setattr(self.w, "deltaLabel%s" % master.id,
TextBox((16, y, -16 - inputWidth, height), master.name))
setattr(self.w, "deltaInput%s" % master.id,
EditText((-16 - inputWidth, y, -16, height), "16"))
# print("self.w.deltaInputs[master.id]", getattr(self.w, "deltaInput%s" % master.id))
y += height + spacing
self.w.submitButton = Button((16, -16 - height, -16, height),
"Adjust all sidebearings",
callback=self.onSubmit)
# finalize UI
self.w.setDefaultButton(self.w.submitButton)
self.loadPreferences()
self.w.bind("close", self.savePreferences)
# make sure window is large enough to show all masters
x, y, w, h = self.w.getPosSize()
if w < minWinSize[0] and h < minWinSize[1]:
self.w.setPosSize((x, y, minWinSize[0], minWinSize[1]),
animate=False)
elif w < minWinSize[0]:
self.w.setPosSize((x, y, minWinSize[0], h), animate=False)
elif h < minWinSize[1]:
self.w.setPosSize((x, y, w, minWinSize[1]), animate=False)
self.w.open()
self.w.makeKey()
def getDeltaInputForMaster(self, masterId):
return getattr(self.w, "deltaInput%s" % masterId)
def loadPreferences(self):
try:
Glyphs.registerDefault(self.valuesPrefsKey, [])
for t in Glyphs.defaults[self.valuesPrefsKey]:
try:
masterId, value = t
self.getDeltaInputForMaster(masterId).set(value)
except:
pass
except:
print("failed to load preferences")
def savePreferences(self, sender):
try:
values = []
for master in Glyphs.font.masters:
values.append(
(master.id, self.getDeltaInputForMaster(master.id).get()))
Glyphs.defaults[self.valuesPrefsKey] = values
except:
print("failed to save preferences")
def onSubmit(self, sender):
try:
sender.enable(False)
if performFontChanges(self.action1):
self.w.close()
except Exception, e:
Glyphs.showMacroWindow()
print("error: %s" % e)
finally:
class Script( object ):
def __init__(self):
self.valuesPrefsKey = prefsKey + ".delta." + basename(Glyphs.font.filepath)
# UI metrics
spacing = 8
height = 22
# calculate window height
minWinSize = (220, 120 + (len(Glyphs.font.masters) * (height + spacing)))
# create UI window
self.w = FloatingWindow(
minWinSize,
"Adjust sidebearings",
minSize=minWinSize,
maxSize=(500, 500),
autosaveName=prefsKey + ".win")
# layout UI controls
y = 16
self.w.label = TextBox((16, y, -16, height), "Sidebearing delta adjustment:")
y += height + spacing
inputWidth = 64
for master in Glyphs.font.masters:
setattr(self.w, "deltaLabel%s" % master.id,
TextBox((16, y, -16-inputWidth, height), master.name))
setattr(self.w, "deltaInput%s" % master.id,
EditText((-16-inputWidth, y, -16, height), "16"))
# print("self.w.deltaInputs[master.id]", getattr(self.w, "deltaInput%s" % master.id))
y += height + spacing
self.w.submitButton = Button(
(16, -16-height, -16, height),
"Adjust all sidebearings",
callback=self.onSubmit)
# finalize UI
self.w.setDefaultButton(self.w.submitButton)
self.loadPreferences()
self.w.bind("close", self.savePreferences)
# make sure window is large enough to show all masters
x, y, w, h = self.w.getPosSize()
if w < minWinSize[0] and h < minWinSize[1]:
self.w.setPosSize((x, y, minWinSize[0], minWinSize[1]), animate=False)
elif w < minWinSize[0]:
self.w.setPosSize((x, y, minWinSize[0], h), animate=False)
elif h < minWinSize[1]:
self.w.setPosSize((x, y, w, minWinSize[1]), animate=False)
self.w.open()
self.w.makeKey()
def getDeltaInputForMaster(self, masterId):
return getattr(self.w, "deltaInput%s" % masterId)
def loadPreferences(self):
try:
Glyphs.registerDefault(self.valuesPrefsKey, [])
for t in Glyphs.defaults[self.valuesPrefsKey]:
try:
masterId, value = t
self.getDeltaInputForMaster(masterId).set(value)
except:
pass
except:
print("failed to load preferences")
def savePreferences(self, sender):
try:
values = []
for master in Glyphs.font.masters:
values.append((master.id, self.getDeltaInputForMaster(master.id).get()))
Glyphs.defaults[self.valuesPrefsKey] = values
except:
print("failed to save preferences")
def onSubmit(self, sender):
try:
sender.enable(False)
if performFontChanges(self.action1):
self.w.close()
except Exception(e):
Glyphs.showMacroWindow()
print("error: %s" % e)
finally:
sender.enable(True)
def action1(self, font):
print(font)
deltas = {} # keyed on master.id
for master in Glyphs.font.masters:
deltas[master.id] = int(self.getDeltaInputForMaster(master.id).get())
syncLayers = set() # layers that need syncMetrics() to be called
# [debug] alterntive loop over a few select glyphs, for debugging.
# debugGlyphNames = set([
# ".null",
# "A", "Adieresis", "Lambda",
# "Bhook",
# "C", "Chook",
# "endash",
# "space",
# ])
# for g in [g for g in font.glyphs if g.name in debugGlyphNames]:
for g in font.glyphs:
# print(">> %s (%s)" % (g.name, g.productionName))
if g.name in excludedGlyphNames:
# glyph is exlcuded
print("ignoring excluded glyph %r" % g.name)
continue
g.beginUndo()
try:
for master in font.masters:
layer = g.layers[master.id]
delta = deltas[master.id]
if delta == 0:
# no adjustment
continue
if layer.width == 0:
# ignore glyphs with zero-width layers
print("ignoring zero-width glyph", g.name)
break
if layer.isAligned:
# ignore glyphs which are auto-aligned from components
print("ignoring auto-aligned glyph", g.name)
break
if len(layer.paths) == 0 and len(layer.components) == 0:
# adjust width instead of LSB & RSB of empty glyphs
if layer.widthMetricsKey is None:
layer.width = max(0, layer.width + (delta * 2))
else:
syncLayers.add(layer)
continue
# offset components by delta to counter-act effect of also applying delta
# to the component glyphs.
if layer.components is not None:
for cn in layer.components:
m = cn.transform
# auto-aligned or offset x or offset y or contains shapes
if not cn.automaticAlignment or m[4] != 0 or m[5] != 0 or len(layer.paths) > 0:
cn.transform = (
m[0], # x scale factor
m[1], # x skew factor
m[2], # y skew factor
m[3], # y scale factor
m[4] - delta, # x position (+ since transform is inverse)
m[5] # y position
)
# Note:
# layer metrics keys are expressions, e.g. "==H+10"
# glyph metrics keys are other glyphs, e.g. U+0041
if g.leftMetricsKey is None and layer.leftMetricsKey is None:
layer.LSB = layer.LSB + delta
else:
syncLayers.add(layer)
if g.rightMetricsKey is None and layer.rightMetricsKey is None:
layer.RSB = layer.RSB + delta
else:
syncLayers.add(layer)
finally:
g.endUndo()
# end for g in font
# sync layers that use metricsKey
if len(syncLayers) > 0:
print("Syncing LSB & RSB for %r layers..." % len(syncLayers))
for layer in syncLayers:
layer.syncMetrics()
print("Done")
class AdjustAnchors(BaseWindowController):
def __init__(self):
self.font = CurrentFont()
self.glyph = CurrentGlyph()
self.upm = self.font.info.unitsPerEm
self.glyphPreviewCacheDict = {} # key: glyph name -- value: list containing assembled glyphs
self.anchorsOnMarksDict = {} # key: anchor name -- value: list of mark glyph names
self.anchorsOnBasesDict = {} # key: anchor name -- value: list of base glyph names
self.marksDict = {} # key: mark glyph name -- value: anchor name (NOTE: It's expected that each mark glyph only has one type of anchor)
self.fillAnchorsAndMarksDicts()
self.glyphNamesList = [] # list of glyph names that will be displayed in the UI list
self.selectedGlyphNamesList = [] # list of glyph names selected in the UI list
self.extraGlyphsList = [] # list of the glyph objects that should be inserted before and after the accented glyphs
self.Blue, self.Alpha = 1, 0.6
self.font.naked().addObserver(self, "fontWasModified", "Font.Changed")
addObserver(self, "_fontWillClose", "fontWillClose")
addObserver(self, "_currentFontChanged", "fontResignCurrent")
addObserver(self, "_currentGlyphChanged", "currentGlyphChanged")
addObserver(self, "_drawFill", "draw")
addObserver(self, "_drawFill", "drawInactive")
addObserver(self, "_previewFill", "drawPreview")
addObserver(self, "_drawGlyphs", "draw") # observer for the draw event
addObserver(self, "_drawGlyphs", "drawInactive") # draw the glyphs when the glyph window is not in focus
addObserver(self, "_drawGlyphs", "drawPreview")
integerNumFormatter = NSNumberFormatter.alloc().init()
integerNumFormatter.setAllowsFloats_(False)
integerNumFormatter.setGeneratesDecimalNumbers_(False)
intPosMinZeroNumFormatter = NSNumberFormatter.alloc().init()
intPosMinZeroNumFormatter.setAllowsFloats_(False)
intPosMinZeroNumFormatter.setGeneratesDecimalNumbers_(False)
intPosMinZeroNumFormatter.setMinimum_(NSNumber.numberWithInt_(0))
intPosMinOneNumFormatter = NSNumberFormatter.alloc().init()
intPosMinOneNumFormatter.setAllowsFloats_(False)
intPosMinOneNumFormatter.setGeneratesDecimalNumbers_(False)
intPosMinOneNumFormatter.setMinimum_(NSNumber.numberWithInt_(1))
self.textSize = getExtensionDefault("%s.%s" % (extensionKey, "textSize"))
if not self.textSize:
self.textSize = 150
self.lineHeight = getExtensionDefault("%s.%s" % (extensionKey, "lineHeight"))
if not self.lineHeight:
self.lineHeight = 200
self.extraSidebearings = getExtensionDefault("%s.%s" % (extensionKey, "extraSidebearings"))
if not self.extraSidebearings:
self.extraSidebearings = [0, 0]
self.extraGlyphs = getExtensionDefault("%s.%s" % (extensionKey, "extraGlyphs"))
if not self.extraGlyphs:
self.extraGlyphs = ''
posSize = getExtensionDefault("%s.%s" % (extensionKey, "posSize"))
if not posSize:
posSize = (100, 100, 1200, 400)
self.calibrateMode = getExtensionDefault("%s.%s" % (extensionKey, "calibrateMode"))
if not self.calibrateMode:
self.calibrateMode = False
calibrateModeStrings = getExtensionDefault("%s.%s" % (extensionKey, "calibrateModeStrings"))
if not calibrateModeStrings:
calibrateModeStrings = {
'group1.baseInput': 'dotlessi o s',
'group1.markInput': 'dieresis circumflex macron breve caron',
'group2.baseInput': 'I O S',
'group2.markInput': 'dieresis.cap circumflex.cap macron.cap breve.cap caron.cap',
'group3.baseInput': 'I.sc O.sc S.sc',
'group3.markInput': 'dieresis circumflex macron breve caron',
'group4.baseInput': '',
'group4.markInput': '',
}
# -- Window --
self.w = FloatingWindow(posSize, extensionName, minSize=(500, 400))
self.w.fontList = List((10, 10, 190, -41), self.glyphNamesList, selectionCallback=self.listSelectionCallback)
if roboFontVersion < '1.7':
self.w.fontList.getNSTableView().sizeToFit() # use the full width of the column
self.w.fontList.show(not self.calibrateMode)
self.w.lineView = MultiLineView((210, 10, -10, -41),
pointSize = self.textSize,
lineHeight = self.lineHeight,
displayOptions={"Beam" : False, "displayMode" : "Multi Line"}
)
# -- Calibration Mode --
baseLabel = "Bases"
markLabel = "Marks"
width, height = 190, 140
self.cm = Group((0, 0, 0, 0))
# ---
self.cm.group1 = Group((5, height*0, width, height-10))
self.cm.group1.baseLabel = TextBox((0, 0, width, 20), baseLabel)
self.cm.group1.baseInput = EditText((0, 21, width, 22), calibrateModeStrings['group1.baseInput'], callback=self.updateCalibrateMode, continuous=False)
self.cm.group1.markLabel = TextBox((0, 50, width, 20), markLabel)
self.cm.group1.markInput = EditText((0, 71, width, 44), calibrateModeStrings['group1.markInput'], callback=self.updateCalibrateMode, continuous=False)
self.cm.group1.divider = HorizontalLine((0, -1, -0, 1))
# ---
self.cm.group2 = Group((5, height*1, width, height-10))
self.cm.group2.baseLabel = TextBox((0, 0, width, 20), baseLabel)
self.cm.group2.baseInput = EditText((0, 21, width, 22), calibrateModeStrings['group2.baseInput'], callback=self.updateCalibrateMode, continuous=False)
self.cm.group2.markLabel = TextBox((0, 50, width, 20), markLabel)
self.cm.group2.markInput = EditText((0, 71, width, 44), calibrateModeStrings['group2.markInput'], callback=self.updateCalibrateMode, continuous=False)
self.cm.group2.divider = HorizontalLine((0, -1, -0, 1))
# ---
self.cm.group3 = Group((5, height*2, width, height-10))
self.cm.group3.baseLabel = TextBox((0, 0, width, 20), baseLabel)
self.cm.group3.baseInput = EditText((0, 21, width, 22), calibrateModeStrings['group3.baseInput'], callback=self.updateCalibrateMode, continuous=False)
self.cm.group3.markLabel = TextBox((0, 50, width, 20), markLabel)
self.cm.group3.markInput = EditText((0, 71, width, 44), calibrateModeStrings['group3.markInput'], callback=self.updateCalibrateMode, continuous=False)
self.cm.group3.divider = HorizontalLine((0, -1, -0, 1))
# ---
self.cm.group4 = Group((5, height*3, width, height-10))
self.cm.group4.baseLabel = TextBox((0, 0, width, 20), baseLabel)
self.cm.group4.baseInput = EditText((0, 21, width, 22), calibrateModeStrings['group4.baseInput'], callback=self.updateCalibrateMode, continuous=False)
self.cm.group4.markLabel = TextBox((0, 50, width, 20), markLabel)
self.cm.group4.markInput = EditText((0, 71, width, 44), calibrateModeStrings['group4.markInput'], callback=self.updateCalibrateMode, continuous=False)
# ---
view = DefconAppKitTopAnchoredNSView.alloc().init()
view.addSubview_(self.cm.getNSView())
view.setFrame_(((0, 0), (width+10, height*4-23)))
self.cm.setPosSize((0, 0, width+10, height*4-22))
self.w.scrollView = ScrollView((5, 10, width+10, -41), view, drawsBackground=False, hasHorizontalScroller=False)
self.w.scrollView.getNSScrollView().setBorderType_(NSNoBorder)
self.w.scrollView.getNSScrollView().setVerticalScrollElasticity_(1) # NSScrollElasticityNone
self.w.scrollView.show(self.calibrateMode)
# -- Footer --
self.w.calibrateModeCheck = CheckBox((10, -32, 200, -10), "Calibration Mode", callback=self.calibrateModeCallback, value=self.calibrateMode)
self.w.textSizeLabel = TextBox((210, -30, 100, -10), "Text Size")
self.w.textSize = EditText((270, -32, 35, -10), self.textSize, callback=self.textSizeCallback, continuous=False, formatter=intPosMinOneNumFormatter)
self.w.lineHeightLabel = TextBox((320, -30, 100, -10), "Line Height")
self.w.lineHeight = EditText((395, -32, 35, -10), self.lineHeight, callback=self.lineHeightCallback, continuous=False, formatter=integerNumFormatter)
self.w.extraSidebearingsLabel = TextBox((446, -30, 180, -10), "Extra Sidebearings")
self.w.extraSidebearingsChar = TextBox((602, -30, 20, -10), "&")
self.w.extraSidebearingLeft = EditText((567, -32, 35, -10), self.extraSidebearings[0], callback=self.extraSidebearingsCallback, continuous=False, formatter=intPosMinZeroNumFormatter)
self.w.extraSidebearingRight = EditText((614, -32, 35, -10), self.extraSidebearings[1], callback=self.extraSidebearingsCallback, continuous=False, formatter=intPosMinZeroNumFormatter)
self.w.extraGlyphsLabel = TextBox((665, -30, 180, -10), "Extra Glyphs")
self.w.extraGlyphs = EditText((749, -32, -10, -10), self.extraGlyphs, callback=self.extraGlyphsCallback, continuous=False)
# trigger the initial state and contents of the window
self.extraGlyphsCallback() # this will call self.updateExtensionWindow()
self.w.bind("close", self.windowClose)
self.w.open()
self.w.makeKey()
def calibrateModeCallback(self, sender):
self.calibrateMode = not self.calibrateMode
self.w.fontList.show(not sender.get())
self.w.scrollView.show(self.calibrateMode)
self.updateExtensionWindow()
def textSizeCallback(self, sender):
try: # in case the user submits an empty field
self.textSize = int(sender.get())
except: # reset to the previous value
NSBeep()
self.sender.set(self.textSize)
self.w.lineView.setPointSize(self.textSize)
def lineHeightCallback(self, sender):
try:
self.lineHeight = int(sender.get())
except:
NSBeep()
self.sender.set(self.lineHeight)
self.w.lineView.setLineHeight(self.lineHeight)
def extraSidebearingsCallback(self, sender):
left = self.w.extraSidebearingLeft
right = self.w.extraSidebearingRight
try:
self.extraSidebearings = [int(left.get()), int(right.get())]
except:
NSBeep()
left.set(self.extraSidebearings[0])
right.set(self.extraSidebearings[1])
self.extraGlyphsCallback() # this will call self.updateExtensionWindow()
def extraGlyphsCallback(self, *sender):
del self.extraGlyphsList[:] # empty the list
self.extraGlyphs = self.w.extraGlyphs.get()
glyphNamesList = self.extraGlyphs.split()
for gName in glyphNamesList:
try:
extraGlyph = self.font[gName]
# must create a new glyph in order to be able to increase the sidebearings without modifying the font
newGlyph = RGlyph()
newGlyph.setParent(self.font)
# must use deepAppend because the extra glyph may have components (which will cause problems to the MultiLineView)
newGlyph = self.deepAppendGlyph(newGlyph, extraGlyph)
newGlyph.width = extraGlyph.width
except RoboFontError:
continue
newGlyph.leftMargin += self.extraSidebearings[0]
newGlyph.rightMargin += self.extraSidebearings[1]
self.extraGlyphsList.append(newGlyph)
self.glyphPreviewCacheDict.clear()
self.updateExtensionWindow()
def windowClose(self, sender):
self.font.naked().removeObserver(self, "Font.Changed")
removeObserver(self, "fontWillClose")
removeObserver(self, "fontResignCurrent")
removeObserver(self, "currentGlyphChanged")
removeObserver(self, "draw")
removeObserver(self, "drawInactive")
removeObserver(self, "drawPreview")
self.saveExtensionDefaults()
def getCalibrateModeStrings(self):
calibrateModeStringsDict = {}
for i in range(1,5):
group = getattr(self.cm, "group%d" % i)
calibrateModeStringsDict["group%d.baseInput" % i] = group.baseInput.get()
calibrateModeStringsDict["group%d.markInput" % i] = group.markInput.get()
return calibrateModeStringsDict
def saveExtensionDefaults(self):
setExtensionDefault("%s.%s" % (extensionKey, "posSize"), self.w.getPosSize())
setExtensionDefault("%s.%s" % (extensionKey, "textSize"), self.textSize)
setExtensionDefault("%s.%s" % (extensionKey, "lineHeight"), self.lineHeight)
setExtensionDefault("%s.%s" % (extensionKey, "extraSidebearings"), self.extraSidebearings)
setExtensionDefault("%s.%s" % (extensionKey, "extraGlyphs"), self.extraGlyphs)
setExtensionDefault("%s.%s" % (extensionKey, "calibrateMode"), self.calibrateMode)
setExtensionDefault("%s.%s" % (extensionKey, "calibrateModeStrings"), self.getCalibrateModeStrings())
def _previewFill(self, info):
self.Blue, self.Alpha = 0, 1
def _drawFill(self, info):
self.Blue, self.Alpha = 1, 0.6
def _fontWillClose(self, info):
"""
Close the window when the last font is closed
"""
if len(AllFonts()) < 2:
self.windowClose(self)
self.w.close()
def _currentFontChanged(self, info):
self.font.naked().removeObserver(self, "Font.Changed")
self.font = CurrentFont()
self.font.naked().addObserver(self, "fontWasModified", "Font.Changed")
self.fillAnchorsAndMarksDicts()
del self.glyphNamesList[:]
del self.selectedGlyphNamesList[:]
self.updateExtensionWindow()
def _currentGlyphChanged(self, info):
self.updateExtensionWindow()
def fontWasModified(self, info):
OutputWindow().clear()
self.fillAnchorsAndMarksDicts()
del self.glyphNamesList[:]
del self.selectedGlyphNamesList[:]
self.updateExtensionWindow()
def deepAppendGlyph(self, glyph, gToAppend, offset=(0,0)):
if not gToAppend.components:
glyph.appendGlyph(gToAppend, offset)
else:
for component in gToAppend.components:
compGlyph = self.font[component.baseGlyph].copy()
# handle component transformations
componentTransformation = component.transformation
# when undoing a paste anchor or a delete anchor action, RoboFont returns component.transformation as a list instead of a tuple
if type(componentTransformation) is list:
componentTransformation = tuple(componentTransformation)
if componentTransformation != (1, 0, 0, 1, 0, 0): # if component is skewed and/or is shifted
matrix = componentTransformation[0:4]
if matrix != (1, 0, 0, 1): # if component is skewed
transformObj = Identity.transform(matrix + (0, 0)) # ignore the original component's shifting values
compGlyph.transform(transformObj)
glyph.appendGlyph(compGlyph, map(sum, zip(component.offset, offset))) # add the two tuples of offset
for contour in gToAppend:
glyph.appendContour(contour, offset)
# if the assembled glyph still has components, recursively remove and replace them 1-by-1 by the glyphs they reference
if glyph.components:
nestedComponent = glyph.components[-1] # start from the end
glyph.removeComponent(nestedComponent)
glyph = self.deepAppendGlyph(glyph, self.font[nestedComponent.baseGlyph], nestedComponent.offset)
return glyph
def updateCalibrateMode(self, *sender):
glyphsList = []
newLine = self.w.lineView.createNewLineGlyph()
# cycle thru the UI Groups and collect the strings
for i in range(1,5):
group = getattr(self.cm, "group%d" % i)
baseGlyphsNamesList = group.baseInput.get().split()
markGlyphsNamesList = group.markInput.get().split()
# iterate thru the base+mark combinations
for gBaseName, gMarkName in product(baseGlyphsNamesList, markGlyphsNamesList):
newGlyph = RGlyph()
newGlyph.setParent(self.font)
# skip invalid glyph names
try:
baseGlyph = self.font[gBaseName]
markGlyph = self.font[gMarkName]
except RoboFontError:
continue
# append base glyph
newGlyph = self.deepAppendGlyph(newGlyph, baseGlyph)
# append mark glyph
newGlyph = self.deepAppendGlyph(newGlyph, markGlyph, self.getAnchorOffsets(baseGlyph, markGlyph))
# set the advanced width
dfltSidebearings = self.upm * .05 # 5% of the UPM
newGlyph.leftMargin = dfltSidebearings + self.extraSidebearings[0]
newGlyph.rightMargin = dfltSidebearings + self.extraSidebearings[1]
# append the assembled glyph to the list
glyphsList.extend(self.extraGlyphsList)
glyphsList.append(newGlyph)
# add line break, if both input fields have content
if baseGlyphsNamesList and markGlyphsNamesList:
glyphsList.extend(self.extraGlyphsList)
glyphsList.append(newLine)
# update the contents of the MultiLineView
self.w.lineView.set(glyphsList)
def updateExtensionWindow(self):
if self.calibrateMode:
self.updateCalibrateMode()
return
if CurrentGlyph() is not None: # NOTE: CurrentGlyph() will return zero (its length), so "is not None" is necessary
self.glyph = CurrentGlyph()
self.glyphNamesList = self.makeGlyphNamesList(self.glyph)
self.updateListView()
currentGlyphName = self.glyph.name
# base glyph + accent combinations preview
# first check if there's a cached glyph
if currentGlyphName in self.glyphPreviewCacheDict:
self.w.lineView.set(self.glyphPreviewCacheDict[currentGlyphName])
# assemble the glyphs
else:
glyphsList = []
for glyphNameInUIList in self.glyphNamesList:
newGlyph = RGlyph()
newGlyph.setParent(self.font)
# the glyph in the UI list is a mark
if glyphNameInUIList in self.marksDict:
markGlyph = self.font[glyphNameInUIList]
# append base glyph
newGlyph = self.deepAppendGlyph(newGlyph, self.glyph)
# append mark glyph
newGlyph = self.deepAppendGlyph(newGlyph, markGlyph, self.getAnchorOffsets(self.glyph, markGlyph))
# set the advanced width
if self.glyph.width < 10: # combining marks or other glyphs with a small advanced width
newGlyph.leftMargin = self.upm * .05 # 5% of the UPM
newGlyph.rightMargin = newGlyph.leftMargin
else:
newGlyph.width = self.glyph.width
# the glyph in the UI list is a base
else:
baseGlyph = self.font[glyphNameInUIList]
# append base glyph
newGlyph = self.deepAppendGlyph(newGlyph, baseGlyph)
# append mark glyph
newGlyph = self.deepAppendGlyph(newGlyph, self.glyph, self.getAnchorOffsets(baseGlyph, self.glyph))
# set the advanced width
if self.glyph.width < 10: # combining marks or other glyphs with a small advanced width
newGlyph.leftMargin = self.upm * .05
newGlyph.rightMargin = newGlyph.leftMargin
else:
newGlyph.width = baseGlyph.width
# pad the new glyph if it has too much overhang
if newGlyph.leftMargin < self.upm * .15:
newGlyph.leftMargin = self.upm * .05
if newGlyph.rightMargin < self.upm * .15:
newGlyph.rightMargin = self.upm * .05
# add extra sidebearings
newGlyph.leftMargin += self.extraSidebearings[0]
newGlyph.rightMargin += self.extraSidebearings[1]
# one last check for making sure the new glyph can be displayed
if not newGlyph.components:
glyphsList.extend(self.extraGlyphsList)
glyphsList.append(newGlyph)
else:
print "Combination with mark glyph %s can't be previewed because it contains component %s." % (glyphNameInUIList, newGlyph.components[0].baseGlyph)
glyphsList.extend(self.extraGlyphsList)
self.w.lineView.set(glyphsList)
# add to the cache
self.glyphPreviewCacheDict[currentGlyphName] = glyphsList
else:
self.w.lineView.set([])
def listSelectionCallback(self, sender):
selectedGlyphNamesList = []
for index in sender.getSelection():
selectedGlyphNamesList.append(self.glyphNamesList[index])
self.selectedGlyphNamesList = selectedGlyphNamesList
self.updateGlyphView()
def updateGlyphView(self):
# update the current glyph view
UpdateCurrentGlyphView()
def fillAnchorsAndMarksDicts(self):
# reset all the dicts
self.glyphPreviewCacheDict.clear()
self.anchorsOnMarksDict.clear()
self.anchorsOnBasesDict.clear()
self.marksDict.clear()
markGlyphsWithMoreThanOneAnchorTypeList = []
for glyphName in self.font.glyphOrder:
glyphAnchorsList = self.font[glyphName].anchors
for anchor in glyphAnchorsList:
if anchor.name[0] == '_':
anchorName = anchor.name[1:]
# add to AnchorsOnMarks dictionary
if anchorName not in self.anchorsOnMarksDict:
self.anchorsOnMarksDict[anchorName] = [glyphName]
else:
tempList = self.anchorsOnMarksDict[anchorName]
tempList.append(glyphName)
self.anchorsOnMarksDict[anchorName] = tempList
# add to Marks dictionary
if glyphName not in self.marksDict:
self.marksDict[glyphName] = anchorName
else:
if glyphName not in markGlyphsWithMoreThanOneAnchorTypeList:
markGlyphsWithMoreThanOneAnchorTypeList.append(glyphName)
else:
anchorName = anchor.name
# add to AnchorsOnBases dictionary
if anchorName not in self.anchorsOnBasesDict:
self.anchorsOnBasesDict[anchorName] = [glyphName]
else:
tempList = self.anchorsOnBasesDict[anchorName]
tempList.append(glyphName)
self.anchorsOnBasesDict[anchorName] = tempList
if markGlyphsWithMoreThanOneAnchorTypeList:
for glyphName in markGlyphsWithMoreThanOneAnchorTypeList:
print "ERROR: Glyph %s has more than one type of anchor." % glyphName
def makeGlyphNamesList(self, glyph):
glyphNamesList = []
markGlyphIsAbleToBeBase = False
if glyph is not None: # NOTE: "if glyph" will return zero (its length), so "is not None" is necessary
# assemble the list for the UI list
for anchor in glyph.anchors:
anchorName = anchor.name
if anchorName in self.anchorsOnMarksDict:
glyphNamesList.extend(self.anchorsOnMarksDict[anchorName])
elif anchorName[1:] in self.anchorsOnBasesDict: # skips the leading underscore
glyphNamesList.extend(self.anchorsOnBasesDict[anchorName[1:]])
# for mark glyphs, test if they're able to get other mark glyphs attached to them
# this will (correctly) prevent the UI list from including glyph names that cannot be displayed with the current glyph
if glyph.name in self.marksDict:
for anchor in glyph.anchors:
if anchor.name[0] != '_': # the current mark glyph has anchors that allow it to be a base for other marks
markGlyphIsAbleToBeBase = True
break
# remove marks from the glyph list if the current mark glyph can't work as a base
if not markGlyphIsAbleToBeBase:
for glyphName in glyphNamesList[::-1]: # iterate from the end of the list
if glyphName in self.marksDict:
glyphNamesList.remove(glyphName)
return glyphNamesList
def updateListView(self):
self.w.fontList.set(self.glyphNamesList)
def getAnchorOffsets(self, canvasGlyph, glyphToDraw):
# the current glyph is a mark
if canvasGlyph.name in self.marksDict:
# glyphToDraw is also a mark (mark-to-mark case)
if glyphToDraw.name in self.marksDict:
# pick the (mark glyph) anchor to draw on
for anchor in canvasGlyph.anchors:
if anchor.name[0] != '_':
anchorName = anchor.name
markAnchor = anchor
break
# pick the (base glyph) anchor to draw on
for anchor in glyphToDraw.anchors:
try:
if anchor.name == '_'+ anchorName:
baseAnchor = anchor
break
except UnboundLocalError:
continue
# glyphToDraw is not a mark
else:
# pick the (mark glyph) anchor to draw on
for anchor in canvasGlyph.anchors:
if anchor.name[0] == '_':
anchorName = anchor.name[1:]
markAnchor = anchor
break
# pick the (base glyph) anchor to draw on
for anchor in glyphToDraw.anchors:
try:
if anchor.name == anchorName:
baseAnchor = anchor
break
except UnboundLocalError:
continue
try:
offsetX = markAnchor.x - baseAnchor.x
offsetY = markAnchor.y - baseAnchor.y
except UnboundLocalError:
offsetX = 0
offsetY = 0
# the current glyph is a base
else:
try:
anchorName = self.marksDict[glyphToDraw.name]
except KeyError:
anchorName = None
if anchorName:
# pick the (base glyph) anchor to draw on
for anchor in canvasGlyph.anchors:
if anchor.name == anchorName:
baseAnchor = anchor
break
# pick the (mark glyph) anchor to draw on
for anchor in glyphToDraw.anchors:
if anchor.name == '_'+ anchorName:
markAnchor = anchor
break
try:
offsetX = baseAnchor.x - markAnchor.x
offsetY = baseAnchor.y - markAnchor.y
except UnboundLocalError:
offsetX = 0
offsetY = 0
return (offsetX, offsetY)
def _drawGlyphs(self, info):
""" draw stuff in the glyph window view """
translateBefore = (0, 0)
for glyphName in self.selectedGlyphNamesList:
glyphToDraw = self.font[glyphName]
# determine the offset of the anchors
offset = self.getAnchorOffsets(self.glyph, glyphToDraw)
# set the offset of the drawing
translate(offset[0] - translateBefore[0], offset[1] - translateBefore[1])
# record the shift amounts (these are needed for resetting the drawing position when more than one mark is selected on the list)
translateBefore = offset
# set the fill & stroke
fill(0, 0, self.Blue, self.Alpha)
strokeWidth(None)
# draw it
mojoPen = MojoDrawingToolsPen(glyphToDraw, self.font)
glyphToDraw.draw(mojoPen)
mojoPen.draw()
class Adhesiontext(BaseWindowController):
def __init__(self):
flushAlign = 76
firstRowY = 12
rowOffsetY = 30
firstCheckY = 135
checkOffsetY = 27
rightMarginX = -12
self.windowWidth = 410
self.windowHeightWithoutOptions = 45
self.windowHeightWithOptions = 280
self.scriptIsRTL = False
windowPos = getExtensionDefault("%s.%s" % (extensionKey, "windowPos"))
if not windowPos:
windowPos = (100, 100)
self.optionsVisible = getExtensionDefault(
"%s.%s" % (extensionKey, "optionsVisible"))
if self.optionsVisible:
optionsButtonSign = '-'
windowHeight = self.windowHeightWithOptions
else:
self.optionsVisible = False # needs to be set because the first time the extension runs self.optionsVisible will be None
optionsButtonSign = '+'
windowHeight = self.windowHeightWithoutOptions
self.chars = getExtensionDefault("%s.%s" % (extensionKey, "chars"))
if not self.chars:
self.chars = ''
self.sliderValue = getExtensionDefault("%s.%s" %
(extensionKey, "sliderValue"))
if not self.sliderValue:
self.sliderValue = 25
self.scriptsIndex = getExtensionDefault("%s.%s" %
(extensionKey, "scriptsIndex"))
if not self.scriptsIndex:
self.scriptsIndex = 0
self.langsIndex = getExtensionDefault("%s.%s" %
(extensionKey, "langsIndex"))
if not self.langsIndex:
self.langsIndex = 0
self.w = FloatingWindow(
(windowPos[0], windowPos[1], self.windowWidth, windowHeight),
"adhesiontext")
# 1st row
self.w.labelChars = TextBox((10, firstRowY, flushAlign, 20),
"Characters:",
alignment="right")
self.w.chars = EditText((flushAlign + 15, firstRowY - 1, 199, 22),
self.chars,
callback=self.charsCallback)
self.w.button = Button((300, firstRowY, 68, 20),
"Get text",
callback=self.buttonCallback)
self.w.spinner = FixedSpinner((325, firstRowY, 20, 20),
displayWhenStopped=False)
self.w.optionsButton = SquareButton((378, firstRowY + 1, 18, 18),
optionsButtonSign,
sizeStyle="small",
callback=self.optionsCallback)
# set the initial state of the button according to the content of the chars EditText
if len(self.w.chars.get()): self.w.button.enable(True)
else: self.w.button.enable(False)
# keep track of the content of chars EditText
self.previousChars = self.w.chars.get()
# 2nd row
self.w.labelWords = TextBox(
(10, firstRowY + rowOffsetY, flushAlign, 20),
"Words:",
alignment="right")
self.w.wordCount = TextBox(
(flushAlign + 12, firstRowY + rowOffsetY, 40, 20),
alignment="left")
self.w.slider = Slider(
(flushAlign + 47, firstRowY + rowOffsetY + 1, 165, 20),
value=self.sliderValue,
minValue=5,
maxValue=200,
callback=self.sliderCallback)
# set the initial wordCount value according to the position of the slider
self.w.wordCount.set(int(self.w.slider.get()))
# 3rd row
self.w.labelScripts = TextBox(
(10, firstRowY + rowOffsetY * 2, flushAlign, 20),
"Script:",
alignment="right")
self.w.scriptsPopup = PopUpButton(
(flushAlign + 15, firstRowY + rowOffsetY * 2, 150, 20),
scriptsNameList,
callback=self.scriptsCallback)
self.w.scriptsPopup.set(self.scriptsIndex)
# 4th row
self.w.labelLangs = TextBox(
(10, firstRowY + rowOffsetY * 3, flushAlign, 20),
"Language:",
alignment="right")
self.w.langsPopup = PopUpButton(
(flushAlign + 15, firstRowY + rowOffsetY * 3, 150, 20), [])
# set the initial list of languages according to the script value
self.w.langsPopup.setItems(
langsNameDict[scriptsNameList[self.w.scriptsPopup.get()]])
self.w.langsPopup.set(self.langsIndex)
self.punctCheck = getExtensionDefault("%s.%s" %
(extensionKey, "punctCheck"))
if not self.punctCheck:
self.punctCheck = 0
self.figsCheck = getExtensionDefault("%s.%s" %
(extensionKey, "figsCheck"))
if not self.figsCheck:
self.figsCheck = 0
self.figsPopup = getExtensionDefault("%s.%s" %
(extensionKey, "figsPopup"))
if not self.figsPopup:
self.figsPopup = 0
self.trimCheck = getExtensionDefault("%s.%s" %
(extensionKey, "trimCheck"))
if not self.trimCheck:
self.trimCheck = 0
self.caseCheck = getExtensionDefault("%s.%s" %
(extensionKey, "caseCheck"))
if not self.caseCheck:
self.caseCheck = 0
self.casingCheck = getExtensionDefault("%s.%s" %
(extensionKey, "casingCheck"))
if not self.casingCheck:
self.casingCheck = 0
self.casingPopup = getExtensionDefault("%s.%s" %
(extensionKey, "casingPopup"))
if not self.casingPopup:
self.casingPopup = 0
# 1st checkbox
self.w.punctCheck = CheckBox((flushAlign + 15, firstCheckY, 130, 20),
"Add punctuation")
self.w.punctCheck.set(self.punctCheck)
# 2nd checkbox
self.w.figsCheck = CheckBox(
(flushAlign + 15, firstCheckY + checkOffsetY, 120, 20),
"Insert numbers",
callback=self.figsCallback)
self.w.figsCheck.set(self.figsCheck)
self.w.figsPopup = PopUpButton(
(210, firstCheckY + checkOffsetY, 90, 20), figOptionsList)
self.w.figsPopup.set(self.figsPopup)
# enable or disable the figure options PopUp depending on the figures CheckBox
if scriptsNameList[self.w.scriptsPopup.get()] in enableFigOptionList:
self.w.figsPopup.show(True)
if self.w.figsCheck.get():
self.w.figsPopup.enable(True)
else:
self.w.figsPopup.enable(False)
else:
self.w.figsPopup.show(False)
# 3rd checkbox
self.w.trimCheck = CheckBoxPlus(
(flushAlign + 15, firstCheckY + checkOffsetY * 2, 120, 20),
"Trim accents")
self.w.trimCheck.set(self.trimCheck)
if scriptsNameList[self.w.scriptsPopup.get()] in enableTrimCheckList:
self.w.trimCheck.enable(True)
else:
self.w.trimCheck.enable(False)
# 4th checkbox
self.w.caseCheck = CheckBoxPlus(
(flushAlign + 15, firstCheckY + checkOffsetY * 3, 120, 20),
"Ignore casing")
self.w.caseCheck.set(self.caseCheck)
if scriptsNameList[self.w.scriptsPopup.get()] in enableCaseCheckList:
self.w.caseCheck.enable(True)
else:
self.w.caseCheck.enable(False)
# 5th checkbox
self.w.casingCheck = CheckBoxPlus(
(flushAlign + 15, firstCheckY + checkOffsetY * 4, 115, 20),
"Change casing",
callback=self.casingCallback)
self.w.casingCheck.set(self.casingCheck)
if scriptsNameList[self.w.scriptsPopup.get()] in enableCaseCheckList:
self.w.casingCheck.enable(True)
else:
self.w.casingCheck.enable(False)
self.w.casingPopup = PopUpButton(
(210, firstCheckY + checkOffsetY * 4, 90, 20), casingNameList)
self.w.casingPopup.set(self.casingPopup)
# enable or disable the casing PopUp depending on the casing CheckBox
if self.w.casingCheck.get() and self.w.casingCheck.isEnable():
self.w.casingPopup.enable(True)
else:
self.w.casingPopup.enable(False)
self.nsTextField = self.w.chars.getNSTextField()
self.w.setDefaultButton(self.w.button)
self.w.bind("close", self.windowClose)
self.w.open()
self.w.makeKey()
def windowClose(self, sender):
self.saveExtensionDefaults()
def saveExtensionDefaults(self):
setExtensionDefault("%s.%s" % (extensionKey, "windowPos"),
self.w.getPosSize()[0:2])
setExtensionDefault("%s.%s" % (extensionKey, "optionsVisible"),
self.optionsVisible)
setExtensionDefault("%s.%s" % (extensionKey, "chars"),
self.w.chars.get())
setExtensionDefault("%s.%s" % (extensionKey, "sliderValue"),
int(self.w.slider.get()))
setExtensionDefault("%s.%s" % (extensionKey, "scriptsIndex"),
int(self.w.scriptsPopup.get()))
setExtensionDefault("%s.%s" % (extensionKey, "langsIndex"),
int(self.w.langsPopup.get()))
setExtensionDefault("%s.%s" % (extensionKey, "punctCheck"),
self.w.punctCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "figsCheck"),
self.w.figsCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "figsPopup"),
self.w.figsPopup.get())
setExtensionDefault("%s.%s" % (extensionKey, "trimCheck"),
self.w.trimCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "caseCheck"),
self.w.caseCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "casingCheck"),
self.w.casingCheck.get())
setExtensionDefault("%s.%s" % (extensionKey, "casingPopup"),
self.w.casingPopup.get())
def buttonCallback(self, sender):
sender.enable(False)
self.w.spinner.start()
self.getText()
self.w.spinner.stop()
sender.enable(True)
def optionsCallback(self, sender):
sign = sender.getTitle()
if sign == "+":
sender.setTitle("-")
self.w.resize(self.windowWidth,
self.windowHeightWithOptions,
animate=True)
self.optionsVisible = True
else:
sender.setTitle("+")
self.w.resize(self.windowWidth,
self.windowHeightWithoutOptions,
animate=True)
self.optionsVisible = False
def charsCallback(self, sender):
charsContent = sender.get()
if len(charsContent):
self.w.button.enable(True)
nsTextView = self.nsTextField.currentEditor(
) # NOTE: the field editor is only available when NSTextField is in editing mode.
# when only one glyph is selected and copied, the contents of the clipboard are the glyph's XML
# instead of its unicode character or its name; therefore, post-process the pasted content.
if xmlHeader in charsContent:
caretIndex = charsContent.index(xmlHeader)
codepointString = re_glyphUnicode.search(charsContent)
glyphName = re_glyphName.search(charsContent)
if codepointString:
replacement = unichr(eval('0x' + codepointString.group(1)))
elif glyphName:
replacement = '/' + glyphName.group(1)
else:
replacement = ''
# replace the glyph's XML by its unicode character or its name
self.w.chars.set(re_glyph.sub(replacement, charsContent))
# restore the location of the caret
location = caretIndex + len(replacement)
nsTextView.setSelectedRange_((location, 0))
# update the variable
charsContent = sender.get()
caretIndex = nsTextView.selectedRanges()[0].rangeValue().location
# Limit the number of characters
numeralWasFound = self.stringHasNumeral(charsContent)
if len(charsContent) > maxChars or numeralWasFound:
NSBeep()
if numeralWasFound:
self.showMessage("Sorry, numerals are not allowed.", "")
else:
self.showMessage(
"You've reached the maximum \rnumber of characters.",
"The limit is %d." % maxChars)
# restore the content of chars EditText to the previous string
sender.set(self.previousChars)
# restore the focus on the chars EditText and restore the location of the caret
caretIndexAdjust = len(self.previousChars) - len(charsContent)
self.w.getNSWindow().makeFirstResponder_(self.nsTextField)
nsTextView.setSelectedRange_(
(caretIndex + caretIndexAdjust, 0))
# update the stored string
self.previousChars = sender.get()
else:
self.w.button.enable(False)
def sliderCallback(self, sender):
self.w.wordCount.set(int(sender.get()))
def scriptsCallback(self, sender):
self.w.langsPopup.setItems(
langsNameDict[scriptsNameList[sender.get()]])
# toggle RTL/LTR
if scriptsNameList[sender.get()] in rightToLeftList:
self.scriptIsRTL = True
self.nsTextField.setBaseWritingDirection_(
NSWritingDirectionRightToLeft)
self.nsTextField.setAlignment_(NSRightTextAlignment)
else:
self.scriptIsRTL = False
self.nsTextField.setBaseWritingDirection_(
NSWritingDirectionLeftToRight)
self.nsTextField.setAlignment_(NSLeftTextAlignment)
# restore the focus on the chars EditText
self.w.getNSWindow().makeFirstResponder_(self.nsTextField)
# toggle figsPopup
if scriptsNameList[sender.get()] in enableFigOptionList:
self.w.figsPopup.show(True)
if self.w.figsCheck.get():
self.w.figsPopup.enable(True)
else:
self.w.figsPopup.enable(False)
else:
self.w.figsPopup.show(False)
# toggle trimCheck
if scriptsNameList[sender.get()] in enableTrimCheckList:
self.w.trimCheck.enable(True)
else:
self.w.trimCheck.enable(False)
# toggle caseCheck and casingCheck
if scriptsNameList[sender.get()] in enableCaseCheckList:
self.w.caseCheck.enable(True)
self.w.casingCheck.enable(True)
if self.w.casingCheck.get():
self.w.casingPopup.enable(True)
else:
self.w.caseCheck.enable(False)
self.w.casingCheck.enable(False)
self.w.casingPopup.enable(False)
def figsCallback(self, sender):
if sender.get():
self.w.figsPopup.enable(True)
else:
self.w.figsPopup.enable(False)
def casingCallback(self, sender):
if sender.get():
self.w.casingPopup.enable(True)
else:
self.w.casingPopup.enable(False)
def stringHasNumeral(self, string):
if re_numeral.search(string):
return True
return False
def isConnected(self):
try:
urlopen(url, timeout=3)
return True
except URLError:
pass
return False
def getText(self):
if CurrentFont() is None:
NSBeep()
self.showMessage("Open a font first.", "")
return
if not self.isConnected():
NSBeep()
self.showMessage("Required internet connection not found.", "")
return
values = {
'chars':
self.w.chars.get().encode('utf-8'),
'script':
scriptsTagDict[scriptsNameList[self.w.scriptsPopup.get()]],
'tb':
langsTagDict[langsNameDict[scriptsNameList[
self.w.scriptsPopup.get()]][self.w.langsPopup.get()]]
}
if self.w.punctCheck.get():
values['punct'] = True
if self.w.figsCheck.get():
values['figs'] = True
if self.w.figsPopup.isVisible():
figsOptTagsList = ["dflt", "locl"]
values['figsOpt'] = figsOptTagsList[self.w.figsPopup.get()]
if self.w.trimCheck.get() and self.w.trimCheck.isEnable():
values['trim'] = True
if self.w.caseCheck.get() and self.w.caseCheck.isEnable():
values['case'] = True
if self.w.casingCheck.get() and self.w.casingCheck.isEnable():
values['casing'] = casingNameList[self.w.casingPopup.get()].lower()
data = urlencode(values)
data = data.encode('utf-8')
print(data)
request = Request(url, data)
response = urlopen(request)
text = response.read()
textU = unicode(text, 'utf-8')
if (msgStr in textU):
textU = textU.replace(msgStr, "")
NSBeep()
self.showMessage(textU, "")
return
elif (wrnStr in textU):
resultIndex = textU.find(rsltStr)
secmsgIndex = textU.find(sndStr)
frstmsgU = textU[:secmsgIndex].replace(wrnStr, "")
scndmsgU = textU[secmsgIndex:resultIndex].replace(sndStr, "")
textU = textU[resultIndex:].replace(rsltStr, "")
NSBeep()
self.showMessage(frstmsgU, scndmsgU)
textList = textU.split()
trimmedText = ' '.join(textList[:int(self.w.slider.get())])
if CurrentSpaceCenter() is None:
OpenSpaceCenter(CurrentFont(), newWindow=False)
sp = CurrentSpaceCenter()
print(trimmedText)
sp.setRaw(trimmedText)
# Toggle RTL-LTR
try:
sp.setLeftToRight(not self.scriptIsRTL)
sp.setInputWritingDirection(
'Right to Left' if self.scriptIsRTL else 'Left to Right')
except AttributeError:
pass
return
