def showAllPairs(self, sender=None):
# open all resulting pairs in Space Center
rawString = ""
for g1, g2 in self.touchingPairs:
rawString += "/%s/%s/space" % (g1, g2)
s = OpenSpaceCenter(self.f)
s.setRaw(rawString)
def showAllPairs(self, sender=None):
# open all resulting pairs in Space Center
rawString = ""
for g1, g2 in self.touchingPairs:
rawString += "/%s/%s/space" % (g1, g2)
s = OpenSpaceCenter(self.f)
s.setRaw(rawString)
def showThisGlyphInSC_CB(self, sender):
if CurrentSpaceCenter() is None:
spaceCenter = OpenSpaceCenter(self.glyph.font)
spaceCenter.set([self.glyphBelowName])
else:
scGlyphs = CurrentSpaceCenter().get()
spaceCenter = OpenSpaceCenter(self.glyph.font)
spaceCenter.set(scGlyphs + [self.glyphBelowName])
def tofuButtonCallback(self, sender):
self.outputText = self.inputText
noBueno = self.tofuText
self.updateFont()
if self.ucCheck == 1:
self.outputText = self.inputText.upper()
noBueno = noBueno.upper()
if self.lcCheck == 1:
self.outputText = self.inputText.lower()
noBueno = noBueno.lower()
if self.digitCheck == 1:
noBueno += s.digits
if self.punctCheck == 1:
noBueno += s.punctuation + "‘’“”«»".decode("utf-8")
self.outputText = removeExtraSpaces("".join(
letter for letter in self.outputText if letter not in noBueno))
# outputText = outputText.translate(None, noBueno)
self.w.outputText.set(self.outputText)
if self.copyToSCCheck == 1 and self.outputText != "":
try:
OpenSpaceCenter(self.font, newWindow=False)
sc = CurrentSpaceCenter()
sc.setRaw(self.outputText)
except AttributeError:
Message("You need a font to copy to Space Center")
def setSpaceCenter(self, font, text):
currentSC = CurrentSpaceCenter()
if currentSC is None:
print('opening space center, click back into MM window')
OpenSpaceCenter(font, newWindow=False)
currentSC = CurrentSpaceCenter()
currentSC.setRaw(text)
def __init__(self):
self.font = CurrentFont()
self.spaceCenter = None
if self.font:
addObserver(self, 'SpaceCenterObserver', 'spaceCenterDidOpen')
self.spaceCenter = OpenSpaceCenter(self.font, newWindow=True)
# addObserver(self, None, 'spaceCenterDraw')
addObserver(self, 'pressedKey', 'spaceCenterKeyDown')
addObserver(self, 'closeSpaceCenter', 'spaceCenterWillClose')
# get kerning from CurrentFont and build text list
self.pairsTextCheck = []
self.kKeys = self.getKerningPairsRef(self.font)
# get reference pairs for flipping
self.refPairs = [pair[0] for pair in self.kKeys]
for key, gkey in self.kKeys:
self.pairsTextCheck.append(self.returnPattern(key))
# index of text
self.i = 0
self.maxi = len(self.kKeys)
self.spaceCenter.set(self.pairsTextCheck[self.i])
else:
message('You need to open a font first!')
def openTab(self, aString):
aString = aString[1:]
if CurrentSpaceCenter():
CurrentSpaceCenter().set(aString)
else:
OpenSpaceCenter(CurrentFont(), newWindow=True)
CurrentSpaceCenter().set(aString)
def __init__(self):
self.font = CurrentFont()
self.spaceCenter = None
if self.font:
addObserver(self, 'SpaceCenterObserver', 'spaceCenterDidOpen')
self.spaceCenter = OpenSpaceCenter(self.font, newWindow=True)
addObserver(self, 'pressedKey', 'spaceCenterKeyDown')
addObserver(self, 'closeSpaceCenter', 'spaceCenterWillClose')
# get kerning from CurrentFont and build text list
self.pairsTextCheck = []
self.kKeys = self.getKerningPairsRef(self.font)
for key, gkey in self.kKeys:
self.pairsTextCheck.append(self.returnPattern(key))
# index of text
self.i = 0
self.maxi = len(self.kKeys)
if self.pairsTextCheck:
self.hasKerning = True
self.spaceCenter.set(self.pairsTextCheck[self.i])
else:
self.hasKerning = False
self.spaceCenter.setRaw('YOUR FONT HAS NO KERNING PAIRS -- your font has no kerning pairs')
else:
message('You need to open a font first!')
def makeWords(self, sender=None):
global warned
self.f = CurrentFont()
self.fontChars = self.fontCharacters(self.f)
self.wordCount = self.getIntegerValue(self.w.basicsBox.wordCount)
self.minLength = self.getIntegerValue(self.w.basicsBox.minLength)
self.maxLength = self.getIntegerValue(self.w.basicsBox.maxLength)
self.case = self.w.basicsBox.case.get()
self.requiredLetters = self.getInputString(self.w.reqBox.mustLettersBox, False)
self.requiredGroups[0] = self.getInputString(self.w.reqBox.group1box, True)
self.requiredGroups[1] = self.getInputString(self.w.reqBox.group2box, True)
self.requiredGroups[2] = self.getInputString(self.w.reqBox.group3box, True)
self.bannedLetters = self.getInputString(self.w.reqBox.notLettersBox, False)
self.bannedLetters.append(" ")
self.limitToCharset = self.w.optionsBox.checkbox0.get()
self.banRepetitions = self.w.optionsBox.checkbox1.get()
self.randomize = self.w.optionsBox.checkbox2.get()
self.outputWords = [] #initialize/empty
checker = wordChecker(self.limitToCharset, self.fontChars, self.requiredLetters, self.requiredGroups, self.bannedLetters, self.banRepetitions, self.minLength, self.maxLength)
for i in self.allWords:
if len(self.outputWords) >= self.wordCount:
break
else:
if self.randomize:
w = choice(self.allWords)
else:
w = i
if self.case == 1: w = w.lower()
elif self.case == 2: w = w.title()
elif self.case == 3: w = w.upper()
if checker.checkWord(w, self.outputWords):
self.outputWords.append(w)
# output
if len(self.outputWords) < 1:
print "word-o-mat: No matching words found <sad trombone>"
else:
outputString = " ".join(self.outputWords)
try:
sp = OpenSpaceCenter(CurrentFont())
sp.setRaw(outputString)
except:
print "word-o-mat:", outputString
pass
def spaceCenter(self, sender):
if CurrentFont() == None:
self.w.textBox.set("Open a font!")
else:
self.font = CurrentFont()
textinput = self.w.textBox.get()
if textinput == "Open a font!":
textinput = ""
sc = OpenSpaceCenter(self.font)
sc.setRaw(textinput)
else:
sc = OpenSpaceCenter(self.font)
sc.setRaw(textinput)
def spaceCenterAllFonts(self, sender):
if CurrentFont() == None:
self.w.textBox.set("Open a font!")
else:
textinput = self.w.textBox.get()
if textinput == "Open a font!":
textinput = ""
for font in AllFonts():
sc = OpenSpaceCenter(font)
sc.setRaw(textinput)
else:
for font in AllFonts():
sc = OpenSpaceCenter(font)
sc.setRaw(textinput)
#
# 2015 Benedikt Bramböck
# @arialcrime
#
#########################################################
from mojo.UI import OpenSpaceCenter
import collections, random, string, os
cities = open('cities.txt', 'r')
letters = string.uppercase
azcities = ''
alphabetdict = collections.defaultdict(list)
for city in cities:
city = city[:-1]
alphabetdict[city[0].upper()].append(city)
#print alphabet
for l in letters:
add = random.choice(alphabetdict[l]) + ' '
azcities += add
# Copy list of cities to clipboard
# os.system("echo '%s' | pbcopy" % azcities)
print azcities
sp = OpenSpaceCenter(CurrentFont())
sp.setRaw(azcities)
#
# 2015 Benedikt Bramböck
# @arialcrime
#
#########################################################
from mojo.UI import OpenSpaceCenter
import collections, random, string, os
cities = open('cities.txt', 'r')
letters = string.uppercase
azcities = ''
alphabetdict = collections.defaultdict(list)
for city in cities:
city = city[:-1]
alphabetdict[city[0].upper()].append(city)
#print alphabet
for l in letters:
add = random.choice(alphabetdict[l]) + ' '
azcities += add
# Copy list of cities to clipboard
# os.system("echo '%s' | pbcopy" % azcities)
print azcities
sp = OpenSpaceCenter(CurrentFont())
sp.setRaw(azcities)
def openSpaceCenter(self, sender):
self._canUpdateChangeCount = False
OpenSpaceCenter(self._font)
self._canUpdateChangeCount = True
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
def makeWords(self, sender=None):
"""Parse user input, save new values to prefs, compile and display the resulting words.
I think this function is too long and bloated, it should be taken apart. ########
"""
global warned
self.f = CurrentFont()
if self.f is not None:
self.fontChars, self.glyphNames = self.fontCharacters(self.f)
self.glyphNamesForValues = {self.fontChars[i]: self.glyphNames[i] for i in range(len(self.fontChars))}
else:
self.fontChars = []
self.glyphNames = []
self.wordCount = self.getIntegerValue(self.g1.wordCount)
self.minLength = self.getIntegerValue(self.g1.minLength)
self.maxLength = self.getIntegerValue(self.g1.maxLength)
self.case = self.g1.case.get()
self.customCharset = []
charset = self.g1.base.get()
self.limitToCharset = True
if charset == 0:
self.limitToCharset = False
elif charset == 2: # use selection
if len(self.f.selection) == 0: # nothing selected
Message("word-o-mat: No glyphs were selected in the font window. Will use any characters available in the current font.")
self.g1.base.set(1) # use font chars
else:
try:
self.customCharset = []
for gname in self.f.selection:
if self.f[gname].unicode is not None:
try:
self.customCharset.append(unichr(int(self.f[gname].unicode)))
except ValueError:
pass
except AttributeError:
pass
elif charset == 3: # use mark color
c = self.g1.colorWell.get()
if c is None:
pass
elif c.className() == "NSCachedWhiteColor": # not set, corresponds to mark color set to None
c = None
self.customCharset = []
self.reqMarkColor = (c.redComponent(), c.greenComponent(), c.blueComponent(), c.alphaComponent()) if c is not None else None
for g in self.f:
if g.mark == self.reqMarkColor:
try:
self.customCharset.append(unichr(int(g.unicode)))
except:
pass
if len(self.customCharset) == 0:
Message("word-o-mat: Found no glyphs that match the specified mark color. Will use any characters available in the current font.")
self.g1.base.set(1) # use font chars
self.toggleColorSwatch(0)
self.matchMode = "text" if self.g2.matchMode.get() == 0 else "grep" # braucht es diese zeile noch?
self.requiredLetters = self.getInputString(self.g2.textMode.mustLettersBox, False)
self.requiredGroups[0] = self.getInputString(self.g2.textMode.group1box, True)
self.requiredGroups[1] = self.getInputString(self.g2.textMode.group2box, True)
self.requiredGroups[2] = self.getInputString(self.g2.textMode.group3box, True)
self.matchPattern = self.g2.grepMode.grepBox.get()
self.banRepetitions = self.g3.checkbox0.get()
self.outputWords = [] # initialize/empty
self.source = self.g1.source.get()
languageCount = len(self.textfiles)
if self.source == languageCount: # User Dictionary
self.allWords = self.dictWords["user"]
elif self.source == languageCount+1: # Use all languages
for i in range(languageCount):
# if any language: concatenate all the wordlists
self.allWords.extend(self.dictWords[self.textfiles[i]])
elif self.source == languageCount+2: # Custom word list
try:
if self.customWords != []:
self.allWords = self.customWords
else:
self.allWords = self.dictWords["ukacd"]
self.g1.source.set(0)
except AttributeError:
self.allWords = self.dictWords["ukacd"]
self.g1.source.set(0)
else: # language lists
for i in range(languageCount):
if self.source == i:
self.allWords = self.dictWords[self.textfiles[i]]
# store new values as defaults
markColorPref = self.reqMarkColor if self.reqMarkColor is not None else "None"
extDefaults = {
"wordCount": self.wordCount,
"minLength": self.minLength,
"maxLength": self.maxLength,
"case": self.case,
"limitToCharset": self.writeExtDefaultBoolean(self.limitToCharset),
"source": self.source,
"matchMode": self.matchMode,
"matchPattern": self.matchPattern, # non compiled string
"markColor": markColorPref,
}
for key, value in extDefaults.iteritems():
setExtensionDefault("com.ninastoessinger.word-o-mat."+key, value)
# go make words
if self.checkInput(self.limitToCharset, self.fontChars, self.customCharset, self.requiredLetters, self.minLength, self.maxLength, self.case) == True:
checker = wordcheck.wordChecker(self.limitToCharset, self.fontChars, self.customCharset, self.requiredLetters, self.requiredGroups, self.matchPatternRE, self.banRepetitions, self.minLength, self.maxLength, matchMode=self.matchMode)
for i in self.allWords:
if len(self.outputWords) >= self.wordCount:
break
else:
w = choice(self.allWords)
if self.case == 1: w = w.lower()
elif self.case == 2:
# special capitalization rules for Dutch IJ
# this only works when Dutch is selected as language, not "any".
try:
ijs = ["ij", "IJ", "Ij"]
if self.languageNames[self.source] == "Dutch" and w[:2] in ijs:
wNew = "IJ" + w[2:]
w = wNew
else:
w = w.title()
except IndexError:
w = w.title()
elif self.case == 3:
# special capitalization rules for German double s
if u"ß" in w:
w2 = w.replace(u"ß", "ss")
w = w2
w = w.upper()
if checker.checkWord(w, self.outputWords):
self.outputWords.append(w)
# output
if len(self.outputWords) < 1:
Message("word-o-mat: no matching words found <sad trombone>")
else:
joinString = " "
if self.g3.listOutput.get() == True:
joinString = "\\n"
self.outputWords = self.sortWordsByWidth(self.outputWords)
outputString = joinString.join(self.outputWords)
try:
sp = OpenSpaceCenter(CurrentFont())
sp.setRaw(outputString)
except:
if warned == False:
Message("word-o-mat: No open fonts found; words will be displayed in the Output Window.")
warned = True
print "word-o-mat:", outputString
else:
print "word-o-mat: Aborted because of errors"
def makeWords(self, sender=None):
global warned
self.f = CurrentFont()
self.fontChars, self.glyphNames = self.fontCharacters(self.f)
self.glyphNamesForValues = {self.fontChars[i]: self.glyphNames[i] for i in range(len(self.fontChars))}
self.wordCount = self.getIntegerValue(self.basicsBox.wordCount)
self.minLength = self.getIntegerValue(self.basicsBox.minLength)
self.maxLength = self.getIntegerValue(self.basicsBox.maxLength)
self.case = self.basicsBox.case.get()
self.customCharset = []
charset = self.basicsBox.radioGroup.get()
self.limitToCharset = True
if charset == 0:
self.limitToCharset = False
else:
if charset == 2: # use selection
if len(self.f.selection) == 0: #nothing selected
Message("No glyphs were selected in the font window. Word-o-mat will use any characters available in the font.")
self.basicsBox.radioGroup.set(1) # use font chars
else:
try:
#self.customCharset = self.f.selection # this just gives me the glyph names
self.customCharset = []
for gname in self.f.selection:
if self.f[gname].unicode is not None: # make sure this does what it should
try:
self.customCharset.append(unichr(int(self.f[gname].unicode)))
except ValueError:
pass
#for entry in self.customCharset:
# print entry
except AttributeError:
pass
self.requiredLetters = self.getInputString(self.reqBox.mustLettersBox, False)
self.requiredGroups[0] = self.getInputString(self.reqBox.group1box, True)
self.requiredGroups[1] = self.getInputString(self.reqBox.group2box, True)
self.requiredGroups[2] = self.getInputString(self.reqBox.group3box, True)
self.banRepetitions = self.reqBox.checkbox0.get()
self.outputWords = [] #initialize/empty
self.source = self.basicsBox.source.get()
languageCount = len(self.textfiles)
if self.source == languageCount: # User Dictionary
self.allWords = self.dictWords["user"]
elif self.source == languageCount+1: # Custom word list
try:
if self.customWords != []:
self.allWords = self.customWords
else:
self.allWords = self.dictWords["ukacd"]
self.basicsBox.source.set(0)
except AttributeError:
self.allWords = self.dictWords["ukacd"]
self.basicsBox.source.set(0)
else: # language lists
for i in range(languageCount):
if self.source == i:
self.allWords = self.dictWords[self.textfiles[i]]
# store new values as defaults
extDefaults = {
"wordCount": self.wordCount,
"minLength": self.minLength,
"maxLength": self.maxLength,
"case": self.case,
"limitToCharset": self.writeExtDefaultBoolean(self.limitToCharset),
"source": self.source,
}
for key, value in extDefaults.iteritems():
setExtensionDefault("com.ninastoessinger.word-o-mat."+key, value)
# go make words
if self.checkInput(self.limitToCharset, self.fontChars, self.customCharset, self.requiredLetters, self.minLength, self.maxLength, self.case) == True:
checker = wordChecker(self.limitToCharset, self.fontChars, self.customCharset, self.requiredLetters, self.requiredGroups, self.banRepetitions, self.minLength, self.maxLength)
for i in self.allWords:
if len(self.outputWords) >= self.wordCount:
break
else:
w = choice(self.allWords)
if self.case == 1: w = w.lower()
elif self.case == 2: w = w.title()
elif self.case == 3: w = w.upper()
if checker.checkWord(w, self.outputWords):
self.outputWords.append(w)
# output
if len(self.outputWords) < 1:
Message("word-o-mat: no matching words found <sad trombone>")
else:
joinString = " "
#if self.reqBox.delimiterRadio.get() == 1:
if self.reqBox.listOutput.get() == True:
joinString = "\\n"
self.outputWords = self.sortWordsByWidth(self.outputWords) ##### NEW / EXPERIMENTAL FEATURE
outputString = joinString.join(self.outputWords)
try:
sp = OpenSpaceCenter(CurrentFont())
sp.setRaw(outputString)
except:
if warned == False:
Message("No open fonts found; word-o-mat will output to the Output Window.")
warned = True
print "word-o-mat:", outputString
else:
print "word-o-mat: Aborted because of errors"
def OpenRoboFontProject(path):
root = os.path.dirname(path)
project = readPlist(path)
documentController = NSDocumentController.sharedDocumentController()
delegate = NSApp().delegate()
openFileNames = [window.representedFilename() for window in NSApp().windows()]
for fileName, data in project["documents"].items():
isUntitled = fileName == "untitled"
if not isUntitled:
if not os.path.exists(fileName):
fileName = os.path.abspath(os.path.join(root, fileName))
if not os.path.exists(fileName):
continue
if fileName in openFileNames:
continue
data.sort(key=lambda item: item.get("name") != "FontWindow")
for windowData in data:
name = windowData["windowName"]
x, y, w, h = windowData["frame"]
if isUntitled:
if name == "FontWindow":
RFont()
elif name == "ScriptingWindow":
delegate.scriptingWindow_(None)
elif name == "FeatureWindow":
delegate.newFeature_(None)
else:
url = NSURL.fileURLWithPath_(fileName)
doc, error = documentController.openDocumentWithContentsOfURL_display_error_(url, True, None)
if error:
delegate.application_openFile_(NSApp(), fileName)
window = NSApp().mainWindow()
vanillaWrapper = None
if hasattr(window.delegate(), "vanillaWrapper"):
vanillaWrapper = window.delegate().vanillaWrapper()
if vanillaWrapper:
font = CurrentFont()
if name == "GlyphWindow":
window = OpenGlyphWindow(font[windowData["glyphName"]], newWindow=True)
window.w.getNSWindow().setFrame_display_animate_(((x, y), (w, h)), True, False)
continue
elif name == "SpaceCenter":
spaceCenter = OpenSpaceCenter(font)
spaceCenter.setPointSize(windowData["pointSize"])
spaceCenter.setPre(windowData["pre"])
spaceCenter.setAfter(windowData["after"])
spaceCenter.set(windowData["input"])
window = CurrentSpaceCenterWindow()
window.w.getNSWindow().setFrame_display_animate_(((x, y), (w, h)), True, False)
continue
window.setFrame_display_animate_(((x, y), (w, h)), True, False)
for windowData in project["toolWindows"]:
name = windowData["windowName"]
x, y, w, h = windowData["frame"]
if name == "DebugWindow":
window = OutputWindow()
window.show()
window.w.getNSWindow().setFrame_display_animate_(((x, y), (w, h)), True, False)
elif name == "InspectorWindow":
try:
# a little bit hacky
# will move to mojo.UI in the upcoming releases
window = delegate._inspectorWindow.w.getNSWindow()
except:
window = None
if window is None:
delegate.openInspector_(None)
window = delegate._inspectorWindow.w.getNSWindow()
window.setFrame_display_animate_(((x, y), (w, h)), True, False)
if "execute" in project:
try:
ScriptRunner(text=project["execute"])
except:
import traceback
print traceback.format_exc(5)
class SpaceCenterKerning(object):
"""class for SpaceCenterKerning"""
def __init__(self):
self.font = CurrentFont()
self.spaceCenter = None
if self.font:
addObserver(self, 'SpaceCenterObserver', 'spaceCenterDidOpen')
self.spaceCenter = OpenSpaceCenter(self.font, newWindow=True)
# addObserver(self, None, 'spaceCenterDraw')
addObserver(self, 'pressedKey', 'spaceCenterKeyDown')
addObserver(self, 'closeSpaceCenter', 'spaceCenterWillClose')
# get kerning from CurrentFont and build text list
self.pairsTextCheck = []
self.kKeys = self.getKerningPairsRef(self.font)
# get reference pairs for flipping
self.refPairs = [pair[0] for pair in self.kKeys]
for key, gkey in self.kKeys:
self.pairsTextCheck.append(self.returnPattern(key))
# index of text
self.i = 0
self.maxi = len(self.kKeys)
self.spaceCenter.set(self.pairsTextCheck[self.i])
else:
message('You need to open a font first!')
def SpaceCenterObserver(self, info):
if self.spaceCenter:
self.spaceCenter.set(self.pairsTextCheck[self.i])
self.updateSpaceCenter()
def pressedKey(self, info):
event = info['event']
pair = self.kKeys[self.i][1]
keyCode = event.keyCode()
# modifier key? alt, shift, None
if event.modifierFlags() == 11010336:
kIncrement = 1
elif event.modifierFlags() == 10617090:
kIncrement = 5
else:
kIncrement = 10
# down, up, left, right keyCodes
if keyCode == 125:
self.i += 1
elif keyCode == 126:
self.i -= 1
elif keyCode == 123:
self.font.kerning[pair] -= kIncrement
elif keyCode == 124:
self.font.kerning[pair] += kIncrement
# flip pair: command-shift-f
elif event.modifierFlags() == 1179914 and keyCode == 3:
# print 'command-shift-f hit!'
refPair = self.kKeys[self.i][0]
flippedPair = refPair[1], refPair[0]
if flippedPair in self.refPairs:
self.i = self.refPairs.index(flippedPair)
else:
print 'Flipped pair (%s, %s) has no kern value' % refPair
# reset if self.i is out of range
if self.i == self.maxi or self.i == -self.maxi:
self.i = 0
self.spaceCenter.set(self.pairsTextCheck[self.i])
def getKerningPairsRef(self, font):
"""use only the main glyph from kerning group and keep the reference"""
kerningRef = font.kerning.keys()[:]
for k in kerningRef:
left, right = k
if left in font.groups:
groupGlyphs = font.groups[left]
groupGlyphs.sort()
# get first glyphname in the group
leftRef = groupGlyphs[0]
else:
leftRef = left
if right in font.groups:
groupGlyphs = font.groups[right]
groupGlyphs.sort()
# get first glyphname in the group
rightRef = groupGlyphs[0]
else:
rightRef = right
i = kerningRef.index(k)
kerningRef[i] = (leftRef, rightRef), (left, right)
kerningRef.sort()
return kerningRef
def returnPattern(self, pair):
"""returns the pattern for each kerning pair for its use in the SpaceCenter"""
left, right = pair
pattern = 'H/O/H/%s/%s/H/O/H/\\n/H/H/H/%s/%s/H/H/H/\\n/O/O/O/%s/%s/o/o/o/\\n/X/H/X/%s/%s/x/o/x' % (
left, right, left, right, left, right, left, right,)
return pattern
def closeSpaceCenter(self, info):
"""remove Observers when closing the custom SpaceCenter"""
removeObserver(self, 'spaceCenterDidOpen')
# removeObserver(self, 'spaceCenterDraw')
removeObserver(self, 'spaceCenterWillClose')
removeObserver(self, 'spaceCenterKeyDown')
def makeWords(self, sender=None):
"""Parse user input, save new values to prefs, compile and display the resulting words.
I think this function is too long and bloated, it should be taken apart. ########
"""
global warned
self.f = CurrentFont()
if self.f is not None:
self.fontChars, self.glyphNames = self.fontCharacters(self.f)
self.glyphNamesForValues = {
self.fontChars[i]: self.glyphNames[i]
for i in range(len(self.fontChars))
}
else:
self.fontChars = []
self.glyphNames = []
self.wordCount = self.getIntegerValue(self.g1.wordCount)
self.minLength = self.getIntegerValue(self.g1.minLength)
self.maxLength = self.getIntegerValue(self.g1.maxLength)
self.case = self.g1.case.get()
self.customCharset = []
charset = self.g1.base.get()
self.limitToCharset = True
if charset == 0:
self.limitToCharset = False
elif charset == 2: # use selection
if len(self.f.selection) == 0: # nothing selected
Message(
"word-o-mat: No glyphs were selected in the font window. Will use any characters available in the current font."
)
self.g1.base.set(1) # use font chars
else:
try:
self.customCharset = []
for gname in self.f.selection:
if self.f[gname].unicode is not None:
try:
self.customCharset.append(
unichr(int(self.f[gname].unicode)))
except ValueError:
pass
except AttributeError:
pass
elif charset == 3: # use mark color
c = self.g1.colorWell.get()
if c is None:
pass
elif c.className(
) == "NSCachedWhiteColor": # not set, corresponds to mark color set to None
c = None
self.customCharset = []
self.reqMarkColor = (c.redComponent(), c.greenComponent(),
c.blueComponent(),
c.alphaComponent()) if c is not None else None
for g in self.f:
if g.mark == self.reqMarkColor:
try:
self.customCharset.append(unichr(int(g.unicode)))
except:
pass
if len(self.customCharset) == 0:
Message(
"word-o-mat: Found no glyphs that match the specified mark color. Will use any characters available in the current font."
)
self.g1.base.set(1) # use font chars
self.toggleColorSwatch(0)
self.matchMode = "text" if self.g2.matchMode.get(
) == 0 else "grep" # braucht es diese zeile noch?
self.requiredLetters = self.getInputString(
self.g2.textMode.mustLettersBox, False)
self.requiredGroups[0] = self.getInputString(
self.g2.textMode.group1box, True)
self.requiredGroups[1] = self.getInputString(
self.g2.textMode.group2box, True)
self.requiredGroups[2] = self.getInputString(
self.g2.textMode.group3box, True)
self.matchPattern = self.g2.grepMode.grepBox.get()
self.banRepetitions = self.g3.checkbox0.get()
self.outputWords = [] # initialize/empty
self.source = self.g1.source.get()
languageCount = len(self.textfiles)
if self.source == languageCount: # User Dictionary
self.allWords = self.dictWords["user"]
elif self.source == languageCount + 1: # Use all languages
for i in range(languageCount):
# if any language: concatenate all the wordlists
self.allWords.extend(self.dictWords[self.textfiles[i]])
elif self.source == languageCount + 2: # Custom word list
try:
if self.customWords != []:
self.allWords = self.customWords
else:
self.allWords = self.dictWords["ukacd"]
self.g1.source.set(0)
except AttributeError:
self.allWords = self.dictWords["ukacd"]
self.g1.source.set(0)
else: # language lists
for i in range(languageCount):
if self.source == i:
self.allWords = self.dictWords[self.textfiles[i]]
# store new values as defaults
markColorPref = self.reqMarkColor if self.reqMarkColor is not None else "None"
extDefaults = {
"wordCount": self.wordCount,
"minLength": self.minLength,
"maxLength": self.maxLength,
"case": self.case,
"limitToCharset": self.writeExtDefaultBoolean(self.limitToCharset),
"source": self.source,
"matchMode": self.matchMode,
"matchPattern": self.matchPattern, # non compiled string
"markColor": markColorPref,
}
for key, value in extDefaults.iteritems():
setExtensionDefault("com.ninastoessinger.word-o-mat." + key, value)
# go make words
if self.checkInput(self.limitToCharset, self.fontChars,
self.customCharset, self.requiredLetters,
self.minLength, self.maxLength, self.case) == True:
checker = wordcheck.wordChecker(self.limitToCharset,
self.fontChars,
self.customCharset,
self.requiredLetters,
self.requiredGroups,
self.matchPatternRE,
self.banRepetitions,
self.minLength,
self.maxLength,
matchMode=self.matchMode)
for i in self.allWords:
if len(self.outputWords) >= self.wordCount:
break
else:
w = choice(self.allWords)
if self.case == 1: w = w.lower()
elif self.case == 2:
# special capitalization rules for Dutch IJ
# this only works when Dutch is selected as language, not "any".
try:
ijs = ["ij", "IJ", "Ij"]
if self.languageNames[
self.source] == "Dutch" and w[:2] in ijs:
wNew = "IJ" + w[2:]
w = wNew
else:
w = w.title()
except IndexError:
w = w.title()
elif self.case == 3:
# special capitalization rules for German double s
if u"ß" in w:
w2 = w.replace(u"ß", "ss")
w = w2
w = w.upper()
if checker.checkWord(w, self.outputWords):
self.outputWords.append(w)
# output
if len(self.outputWords) < 1:
Message("word-o-mat: no matching words found <sad trombone>")
else:
joinString = " "
if self.g3.listOutput.get() == True:
joinString = "\\n"
self.outputWords = self.sortWordsByWidth(self.outputWords)
outputString = joinString.join(self.outputWords)
try:
sp = OpenSpaceCenter(CurrentFont())
sp.setRaw(outputString)
except:
if warned == False:
Message(
"word-o-mat: No open fonts found; words will be displayed in the Output Window."
)
warned = True
print "word-o-mat:", outputString
def openClusterInSpaceCenterCallback(self, sender):
spaceCenter = OpenSpaceCenter(self.glyph.font)
spaceCenter.set([glyph.glyph.name for glyph in self.glyphList])
