1 files changed, 0 insertions, 339 deletions
diff --git a/misc/pylib/robofab/tools/toolsFL.py b/misc/pylib/robofab/tools/toolsFL.py
deleted file mode 100755
index c8aff19a1..000000000
--- a/misc/pylib/robofab/tools/toolsFL.py
+++ /dev/null
@@ -1,339 +0,0 @@
-"""
-T.O.O.L.S.: Things Other Objects Lack (Sometimes)
--assorted raw tools.
-
-This is an assorted colection of raw tools that do
-things inside of FontLab. Many of these functions
-form the bedrock of objectsFL. In short, use these
-tools only if you need the raw functions and they are
-not supported by the objects.
-
-Object model:
-Most of these tools were written before
-objectsFL. Some of these tools are used by
-objectsFL. That means that if you want to
-use functions from robofab.tools you can always
-feed them FontLab objects (like Font, Glyps,
-etc.). If the functions also accept Robjects from
-robofab.objects it is usually mentioned in the
-doc string.
-
-This is a simple way to convert a robofab Font
-object back to a FL Font object. Even if you don't
-know which particular faith an object belongs to
-you can use this:
-
-font = unwrapFont(font)
-"""
-
-
-from FL import *
-from warnings import warn
-
-try:
-	from fl_cmd import *
-except ImportError:
-	print "The fl_cmd module is not available here. toolsFL.py"
-	
-import os
-
-from robofab import RoboFabError
-
-# local encoding
-if os.name == "mac":
-	LOCAL_ENCODING = "macroman"
-else:
-	LOCAL_ENCODING = "latin-1"
-	
-	
-#
-#
-#
-#	stuff for fontlab app
-#
-#
-#
-
-def AppFolderRenamer():
-	"""This function will rename the folder that contains the
-	FontLab application to a more specific name that includes
-	the version of the application
-	Warning: it messes with the paths of your app, if you have
-	items that hardwired to this path you'd be in trouble.
-	"""
-	if fl.count > 0:
-		warn("Close all fonts before running AppFolderRenamer")
-		return
-	old = fl.path[:-1]
-	root = os.path.dirname(old)
-	new = "FontLab " + fl.version.replace('/', '_')
-	path = os.path.join(root, new)
-	if path != old:
-		try:
-			os.rename(old, path)
-		except OSError:
-			pass
-		warn("Please quit and restart FontLab")
-			
-#
-#
-#
-#	stuff for fonts
-#
-#
-#
-
-def GetFont(full_name):
-	"""Return fontobjects which match full_name.
-	Note: result is a list.
-	Returns: a list of FL Font objects
-	"""
-	found = []
-	for f in AllFonts():
-		if f.full_name == full_name:
-			found.append(f)
-	return found
-
-def AllFonts():
-	"""Collect a list of all open fonts.
-	Returns: a list of FL Font objects.
-	"""
-	fontcount = len(fl)
-	af = []
-	for i in range(fontcount):
-		af.append(fl[i])
-	return af
-
-def FontIndex(font):
-	"""return the index of a specified FL Font"""
-	font = unwrapFont(font)
-	a = AllFonts()
-	p = []
-	for f in a:
-		p.append(f.file_name)
-	if font.file_name in p:
-		return p.index(font.file_name)
-	else:
-		return None
-		
-def unwrapFont(font):
-	"""Unwrap the font if it happens to be a RoboFab Font"""
-	if hasattr(font, 'isRobofab'):
-		return font.naked()
-	return font
-
-def MakeTempFont(font, dupemark=None, removeOverlap=True, decompose=True):
-	"""Save the current FL Font,
-	- close the file,
-	- duplicate the file in the finder (icon looks weird, but it works)
-	- open the duplicate
-	- decompose the glyphs
-	- remove overlaps
-	- return the fontobject
-
-	font  is either a FL Font or RF RFont object.
-	
-	Problems: doesn't check if the filename is getting too long.
-	Note: it will overwrite older files with the same name.
-	"""	
-	import string
-	f = unwrapFont(font)
-	if not dupemark or dupemark == "":
-		dupemark = "_tmp_"
-	path = f.file_name
-	a = f.file_name.split('.')
-	a.insert(len(a)-1, dupemark)
-	newpath = string.join(a, '.')
-	f.Save(path)
-	fl.Close(FontIndex(f))
-	file = open(path, 'rb')
-	data = file.read()
-	file.close()
-	file = open(newpath, 'wb')
-	file.write(data)
-	file.close()
-	fl.Open(newpath, 1)
-	nf = fl.font
-	if nf is None:
-		print 'uh oh, sup?'
-		return None
-	else:
-		for g in nf.glyphs:
-			if decompose:
-				g.Decompose()
-			if removeOverlap:
-				g.RemoveOverlap()
-		return nf
-
-def makePSFontName(name):
-	"""Create a postscript filename out of a regular postscript fontname,
-	using the old fashioned macintosh 5:3:3 convention.
-	"""
-	import string
-	parts = []
-	current = []
-	final = []
-	notAllowed = '-_+=,-'
-	index = 0
-	for c in name:
-		if c in notAllowed:
-			continue
-		if c in string.uppercase or index == 0:
-			c = string.upper(c)
-			if current:
-				parts.append("".join(current))
-			current = [c]
-		else:
-			current.append(c)
-		index = index + 1
-	if current:
-		parts.append("".join(current))
-	final.append(parts[0][:5])
-	for p in parts[1:]:
-		final.append(p[:3])
-	return "".join(final)
-
-#
-#
-#
-#	stuff for glyphs
-#
-#
-#
-
-def NewGlyph(font, glyphName, clear=False, updateFont=True):
-	"""Make a new glyph if it doesn't already exist, return the glyph.
-	font is either a FL Font or RF RFont object. If updateFont is True
-	the (very slow) fl.UpdateFont function will be called.
-	"""
-	font = unwrapFont(font)
-	if isinstance(glyphName, unicode):
-		glyphName = glyphName.encode(LOCAL_ENCODING)
-	glyph = font[glyphName]
-	if glyph is None:
-		new = Glyph()
-		new.name = glyphName
-		font.glyphs.append(new)
-		if updateFont:
-			fl.UpdateFont(FontIndex(font))
-		glyph = font[glyphName]
-	elif clear:
-		glyph.Clear()
-		glyph.anchors.clean()
-		glyph.components.clean()
-		glyph.note = ""
-	return glyph
-
-
-def AddToAlias(additions, sep='+'):
-	"""additions is a dict with glyphnames as keys
-	and glyphConstruction as values. In order to make
-	a bunch of additions in one go rather than open
-	and close the file for each name.	Add a glyph
-	to the alias.dat file if it doesn't already exist.
-	additions = {'Gcircumflex': ['G','circumflex'], }
-	Returns a list of only the added glyphnames."""
-	import string
-	glyphs = {}
-	data = []
-	new = []
-	path = os.path.join(fl.path, 'Mapping', 'alias.dat')
-	if os.path.exists(path):
-		file = open(path, 'r')
-		data = file.read().split('\n')
-		file.close()
-	for i in data:
-		if len(i) == 0: continue
-		if i[0] != '%':
-			glyphs[i.split(' ')[0]] = i.split(' ')[1]
-	for glyphName, glyphConstruction in additions.items():
-		if glyphName not in glyphs.keys():
-			new.append(glyphName)
-			glyphs[glyphName] = string.join(glyphConstruction, sep)
-	newNames = ['%%FONTLAB ALIASES']
-	l = glyphs.keys()
-	l.sort()
-	for i in l:
-		newNames.append(string.join([i, glyphs[i]], ' '))
-		file = open(path, 'w')
-		file.write(string.join(newNames, '\n'))
-		file.close()
-	return new
-
-
-def GlyphIndexTable(font):
-	"""Make a glyph index table for font"""
-	font = unwrapFont(font)
-	idx = {}
-	for i in range(len(font)):
-		g = font.glyphs[i]
-		idx[g.name] = i
-	return idx
-
-def MakeReverseCompoMapping(font):
-	"""Return a dict that maps glyph names to lists containing tuples
-	of the form:
-	   (clientGlyphName, componentIndex)
-	"""
-	font = unwrapFont(font)
-	reverseCompoMapping = {}
-	for g in font.glyphs:
-		for i, c in zip(range(len(g.components)), g.components):
-			base = font[c.index].name
-			if not base in reverseCompoMapping:
-				reverseCompoMapping[base] = []
-			reverseCompoMapping[base].append((g.name, i))
-	return reverseCompoMapping
-
-
-#
-#
-#
-#	stuff for text files
-#
-#
-#
-
-def textPrinter(text, name=None, path=None):
-	"""Write a string to a text file. If no name is given it becomes
-	Untitled_hour_minute_second.txt . If no path is given it goes
-	into the FontLab/RoboFab Data directory."""
-	if not name:
-		import time
-		tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst = time.localtime()
-		now = '_'.join((`tm_hour`, `tm_min`, `tm_sec`))
-		name = 'Untitled_%s.txt'%now
-	if not path:
-		path = os.path.join(makeDataFolder(), name)
-	f = open(path, 'wb')
-	f.write(text)
-	f.close()
-
-def makeDataFolder():
-	"""Make the RoboFab data folder"""
-	folderPath = os.path.join(fl.path, "RoboFab Data")
-	if not os.path.exists(folderPath):
-		try:
-			os.makedirs(folderPath)
-		except:
-			pass
-	return folderPath
-	
-
-def Log(text=None):
-	"""Make an entry in the default log file."""
-	now = str(time.asctime(time.localtime(time.time())))
-	if not text:
-		text = "-"
-	entry = "%s: %s\r"%(now, text)
-	path = os.path.join(os.getcwd(), "Logs")
-	new = 0
-	if not os.path.exists(path):
-		os.makedirs(path)
-		new = 1
-	log = os.path.join(path, "log.txt")
-	f = open(log, 'a')
-	if new:
-		f.write("# log file for FL\r")
-	f.write(entry)
-	f.close()