ajout fichiers manquant

venv/Lib/site-packages/fontTools/varLib/builder.py

@@ -0,0 +1,137 @@
+from fontTools import ttLib
+from fontTools.ttLib.tables import otTables as ot
+
+# VariationStore
+
+def buildVarRegionAxis(axisSupport):
+	self = ot.VarRegionAxis()
+	self.StartCoord, self.PeakCoord, self.EndCoord = [float(v) for v in axisSupport]
+	return self
+
+def buildVarRegion(support, axisTags):
+	assert all(tag in axisTags for tag in support.keys()), ("Unknown axis tag found.", support, axisTags)
+	self = ot.VarRegion()
+	self.VarRegionAxis = []
+	for tag in axisTags:
+		self.VarRegionAxis.append(buildVarRegionAxis(support.get(tag, (0,0,0))))
+	return self
+
+def buildVarRegionList(supports, axisTags):
+	self = ot.VarRegionList()
+	self.RegionAxisCount = len(axisTags)
+	self.Region = []
+	for support in supports:
+		self.Region.append(buildVarRegion(support, axisTags))
+	self.RegionCount = len(self.Region)
+	return self
+
+
+def _reorderItem(lst, mapping):
+	return [lst[i] for i in mapping]
+
+def VarData_calculateNumShorts(self, optimize=False):
+	count = self.VarRegionCount
+	items = self.Item
+	bit_lengths = [0] * count
+	for item in items:
+		# The "+ (i < -1)" magic is to handle two's-compliment.
+		# That is, we want to get back 7 for -128, whereas
+		# bit_length() returns 8. Similarly for -65536.
+		# The reason "i < -1" is used instead of "i < 0" is that
+		# the latter would make it return 0 for "-1" instead of 1.
+		bl = [(i + (i < -1)).bit_length() for i in item]
+		bit_lengths = [max(*pair) for pair in zip(bl, bit_lengths)]
+	# The addition of 8, instead of seven, is to account for the sign bit.
+	# This "((b + 8) >> 3) if b else 0" when combined with the above
+	# "(i + (i < -1)).bit_length()" is a faster way to compute byte-lengths
+	# conforming to:
+	#
+	# byte_length = (0 if i == 0 else
+	#		 1 if -128 <= i < 128 else
+	#		 2 if -65536 <= i < 65536 else
+	#		 ...)
+	byte_lengths = [((b + 8) >> 3) if b else 0 for b in bit_lengths]
+
+	# https://github.com/fonttools/fonttools/issues/2279
+	longWords = any(b > 2 for b in byte_lengths)
+
+	if optimize:
+		# Reorder columns such that wider columns come before narrower columns
+		mapping = []
+		mapping.extend(i for i,b in enumerate(byte_lengths) if b > 2)
+		mapping.extend(i for i,b in enumerate(byte_lengths) if b == 2)
+		mapping.extend(i for i,b in enumerate(byte_lengths) if b == 1)
+
+		byte_lengths = _reorderItem(byte_lengths, mapping)
+		self.VarRegionIndex = _reorderItem(self.VarRegionIndex, mapping)
+		self.VarRegionCount = len(self.VarRegionIndex)
+		for i in range(len(items)):
+			items[i] = _reorderItem(items[i], mapping)
+
+	if longWords:
+		self.NumShorts = max((i for i,b in enumerate(byte_lengths) if b > 2), default=-1) + 1
+		self.NumShorts |= 0x8000
+	else:
+		self.NumShorts = max((i for i,b in enumerate(byte_lengths) if b > 1), default=-1) + 1
+
+	self.VarRegionCount = len(self.VarRegionIndex)
+	return self
+
+ot.VarData.calculateNumShorts = VarData_calculateNumShorts
+
+def VarData_CalculateNumShorts(self, optimize=True):
+	"""Deprecated name for VarData_calculateNumShorts() which
+	defaults to optimize=True.  Use varData.calculateNumShorts()
+	or varData.optimize()."""
+	return VarData_calculateNumShorts(self, optimize=optimize)
+
+def VarData_optimize(self):
+	return VarData_calculateNumShorts(self, optimize=True)
+
+ot.VarData.optimize = VarData_optimize
+
+
+def buildVarData(varRegionIndices, items, optimize=True):
+	self = ot.VarData()
+	self.VarRegionIndex = list(varRegionIndices)
+	regionCount = self.VarRegionCount = len(self.VarRegionIndex)
+	records = self.Item = []
+	if items:
+		for item in items:
+			assert len(item) == regionCount
+			records.append(list(item))
+	self.ItemCount = len(self.Item)
+	self.calculateNumShorts(optimize=optimize)
+	return self
+
+
+def buildVarStore(varRegionList, varDataList):
+	self = ot.VarStore()
+	self.Format = 1
+	self.VarRegionList = varRegionList
+	self.VarData = list(varDataList)
+	self.VarDataCount = len(self.VarData)
+	return self
+
+
+# Variation helpers
+
+def buildVarIdxMap(varIdxes, glyphOrder):
+	self = ot.VarIdxMap()
+	self.mapping = {g:v for g,v in zip(glyphOrder, varIdxes)}
+	return self
+
+
+def buildDeltaSetIndexMap(varIdxes):
+	self = ot.DeltaSetIndexMap()
+	self.mapping = list(varIdxes)
+	self.Format = 1 if len(varIdxes) > 0xFFFF else 0
+	return self
+
+
+def buildVarDevTable(varIdx):
+	self = ot.Device()
+	self.DeltaFormat = 0x8000
+	self.StartSize = varIdx >> 16
+	self.EndSize = varIdx & 0xFFFF
+	return self