def glyph_setBasics(self, mode):
font = pFont()
process_glyphs = getProcessGlyphs(pMode)
processed_glyphs = []
for n, glyph in enumerate(process_glyphs):
if mode == 'flag':
wLayers = glyph._prepareLayers(pLayers)
for layer in wLayers:
glyph.setMark(
self.color_codes[self.cmb_select_color.currentText],
None)
if mode == 'name':
new_name = str(self.edt_glyphName.text)
if number_token in new_name:
token_count = new_name.count(number_token)
new_name = new_name.replace('#' * token_count,
'%s') % fromat_number(
n, token_count)
if font.hasGlyph(new_name):
new_name = '%s.%s' % (new_name, str(n))
glyph.setName(new_name)
if mode == 'tags':
glyph.setTags(str(self.edt_glyphTags.text).split(' '))
processed_glyphs.append(glyph.name)
font.updateObject(
font.fl,
'Set Glyph(s) %s | %s' % (mode, ', '.join(processed_glyphs)))
def exportExpr(self):
font = pFont()
fontPath = os.path.split(font.fg.path)[0]
fname = QtGui.QFileDialog.getSaveFileName(self, 'Save Metrics to file',
fontPath, '*.json')
if self.cmb_mode.currentIndex == 1:
expGlyphBounds = {
glyph.name: {
layer.name:
(glyph.getLSB(layer.name), glyph.getRSB(layer.name),
glyph.getAdvance(layer.name))
for layer in glyph.masters()
}
for glyph in font.pGlyphs()
}
print 'EXPORT MM:\t Font:%s; Glyph Metrics found: %s.' % (
font.name, len(expGlyphBounds.keys()))
else:
expGlyphBounds = {
glyph.name:
(glyph.getLSB(fixedLayer), glyph.getRSB(fixedLayer),
glyph.getAdvance(fixedLayer))
for glyph in font.pGlyphs()
}
print 'EXPORT:\t Font:%s; Glyph Metrics found: %s.' % (
font.name, len(expGlyphBounds.keys()))
with open(fname, 'w') as exportFile:
json.dump(expGlyphBounds, exportFile)
print 'SAVE:\t Font:%s; %s Glyph Metrics saved to %s.' % (
font.name, len(expGlyphBounds.keys()), fname)
def copyExpr(self):
font = pFont()
if self.cmb_mode.currentIndex == 1:
self.srcGlyphBounds = {
glyph.name: {
layer.name:
(glyph.getLSB(layer.name), glyph.getRSB(layer.name),
glyph.getAdvance(layer.name))
for layer in glyph.masters()
}
for glyph in font.pGlyphs()
}
print 'COPY MM:\t Font:%s; Glyph Metric Values copied: %s.' % (
font.name, len(self.srcGlyphBounds.keys()))
else:
self.srcGlyphBounds = {
glyph.name:
(glyph.getLSB(fixedLayer), glyph.getRSB(fixedLayer),
glyph.getAdvance(fixedLayer))
for glyph in font.pGlyphs()
}
print 'COPY:\t Font:%s; Glyph Metric Values copied: %s.' % (
font.name, len(self.srcGlyphBounds.keys()))
self.btn_pasteADV.setEnabled(True)
self.btn_pasteRSB.setEnabled(True)
def table_populate(self, mode):
def check_type(layer):
if layer.isMaskLayer: return 'Mask'
if layer.isMasterLayer: return 'Master'
if layer.isService: return 'Service'
if fl6.CurrentFont() is not None and fl6.CurrentGlyph() is not None:
active_font = pFont()
active_glyph = pGlyph()
if mode == 0:
init_data = [(layer.name, check_type(layer))
for layer in active_glyph.layers()
if '#' not in layer.name]
else:
init_data = [(master, 'Master')
for master in active_font.pMasters.names]
table_dict = {
n: OrderedDict(zip(column_names, data))
for n, data in enumerate(init_data)
}
self.tab_masters.clear()
self.tab_masters.setTable(table_dict,
color_dict=color_dict,
enable_check=True)
def glyph_insert(self, asMask=False):
font = pFont()
src_glyph_name = self.edt_sourceName.text
processed_glyphs = []
if len(src_glyph_name) and font.hasGlyph(src_glyph_name):
copy_options = self.__getOptions()
process_glyphs = getProcessGlyphs(pMode)
src_glyph = font.glyph(src_glyph_name)
for dst_glyph in process_glyphs:
for src_layer in src_glyph.layers():
src_layer_name = src_layer.name
if '#' not in src_layer_name:
new_layer = dst_glyph.importLayer(
src_glyph, src_layer_name, src_layer_name,
copy_options, True, False, True,
('insert', 'mask')[asMask])
new_transform, org_transform, rev_transform = self.tr_trans_ctrl.getTransform(
new_layer.boundingBox)
new_layer.applyTransform(org_transform)
new_layer.applyTransform(new_transform)
new_layer.applyTransform(rev_transform)
processed_glyphs.append(dst_glyph.name)
font.updateObject(
font.fl, 'Insert Glyph: %s --> %s;' %
(src_glyph_name, ', '.join(processed_glyphs)))
else:
warnings.warn(
'Glyph not found: %s;' %
(None, src_glyph_name)[1 if len(src_glyph_name) else 0],
GlyphWarning)
def tag_glyphs(self, mode):
# - Init
new_tags = self.edt_tagString.text.replace(' ', '').split(',')
# - Helper
def tag(glyph, tagList):
glyph.setTags(tagList)
glyph.updateObject(
glyph.fl, 'Glyph: %s; Add tags: %s ' % (glyph.name, tagList))
glyph.update()
# - Process
if mode == 'G':
glyph = eGlyph()
tag(glyph, new_tags)
else:
process_glyphs = []
if mode == 'W':
process_glyphs = [
pGlyph(glyph)
for glyph in pWorkspace().getTextBlockGlyphs()
]
elif mode == 'S':
process_glyphs = pFont().selected_pGlyphs()
for glyph in process_glyphs:
tag(glyph, new_tags)
self.edt_tagString.clear()
def __init__(self, parentWidget):
super(WFontZones, self).__init__()
# - Init
self.grid = QtGui.QGridLayout()
self.upperWidget = parentWidget
self.activeFont = pFont()
self.zoneData = {
master: self.activeFont.zonesToTuples(master)
for master in self.activeFont.masters()
}
# - Interface
self.btn_apply = QtGui.QPushButton('Apply Changes')
self.btn_reset = QtGui.QPushButton('Reset')
self.btn_open = QtGui.QPushButton('Open')
self.btn_save = QtGui.QPushButton('Save')
self.btn_new = QtGui.QPushButton('Add New')
self.btn_del = QtGui.QPushButton('Delete')
self.cmb_layer = QtGui.QComboBox()
self.cmb_layer.addItems(['All Layers'] + self.activeFont.masters())
self.edt_pos = TRZLineEdit()
self.edt_width = QtGui.QLineEdit()
self.edt_name = QtGui.QLineEdit()
self.edt_name.setPlaceholderText('Name')
self.edt_pos.setPlaceholderText('Position')
self.edt_width.setPlaceholderText('Width')
self.btn_apply.clicked.connect(self.applyChanges)
self.btn_reset.clicked.connect(self.resetChanges)
self.btn_save.clicked.connect(self.exportZones)
self.btn_open.clicked.connect(self.importZones)
self.btn_new.clicked.connect(self.addZone)
self.btn_del.clicked.connect(self.delZone)
self.tree_fontZones = WTreeWidget(self.zoneData)
# - Build
lbl_name = QtGui.QLabel('Font Zones (Local)')
lbl_name.setMaximumHeight(20)
self.grid.addWidget(lbl_name, 0, 0, 1, 24)
self.grid.addWidget(self.tree_fontZones, 1, 0, 15, 21)
self.grid.addWidget(self.cmb_layer, 1, 21, 1, 3)
self.grid.addWidget(self.edt_name, 2, 21, 1, 3)
self.grid.addWidget(self.edt_pos, 3, 21, 1, 3)
self.grid.addWidget(self.edt_width, 4, 21, 1, 3)
self.grid.addWidget(self.btn_new, 5, 21, 1, 3)
self.grid.addWidget(self.btn_del, 6, 21, 1, 3)
self.grid.addWidget(self.btn_save, 12, 21, 1, 3)
self.grid.addWidget(self.btn_open, 13, 21, 1, 3)
self.grid.addWidget(self.btn_reset, 14, 21, 1, 3)
self.grid.addWidget(self.btn_apply, 15, 21, 1, 3)
self.setLayout(self.grid)
def drop_guide_H(self):
font = pFont()
glyph = eGlyph()
src_glyph = glyph
src_name = self.edt_sourceName.text
if len(src_name) and font.hasGlyph(src_name):
src_glyph = font.glyph(src_name)
wLayers = glyph._prepareLayers(pLayers)
italicAngle = 0 #glyph.package.italicAngle_value
guide_name = self.edt_guideName.text if len(
self.edt_guideName.text) else '%s:%s:%s%%' % (
src_name, self.cmb_select_H.currentText, self.spb_prc_H.value)
for layerName in wLayers:
metrics = pFontMetrics(glyph.package)
if 'BBox' in self.cmb_select_H.currentText:
height = src_glyph.layer(layerName).boundingBox.height()
origin = glyph.layer(layerName).boundingBox.y()
elif 'Adv' in self.cmb_select_H.currentText:
height = src_glyph.layer(layerName).advanceHeight
origin = 0.
elif 'X-H' in self.cmb_select_H.currentText:
height = metrics.getXHeight(layerName)
origin = 0.
elif 'Caps' in self.cmb_select_H.currentText:
height = metrics.getCapsHeight(layerName)
origin = 0.
elif 'Ascender' in self.cmb_select_H.currentText:
height = metrics.getAscender(layerName)
origin = 0.
elif 'Descender' in self.cmb_select_H.currentText:
height = metrics.getDescender(layerName)
origin = 0.
guidePos = (0, float(height) * self.spb_prc_H.value / 100 +
origin + self.spb_unit_H.value)
glyph.addGuideline(guidePos,
layer=layerName,
angle=90,
name=guide_name,
tag=self.edt_guideTag.text,
color=self.cmb_select_color.currentText)
glyph.updateObject(
glyph.fl,
'Drop Guide <%s> @ %s.' % (self.edt_guideName.text, '; '.join(
glyph._prepareLayers(pLayers))))
glyph.update()
def preset_reset(self):
self.builder = None
self.active_font = pFont()
self.font_masters = self.active_font.masters()
self.table_dict = self.empty_preset(0)
self.tab_presets.clear()
self.tab_presets.setTable(self.table_dict, sortData=(False, False))
self.tab_presets.horizontalHeader().setStretchLastSection(False)
self.tab_presets.verticalHeader().hide()
def populate_shapes(self):
self.active_font = pFont()
self.font_shapes = {}
for glyph in self.active_font.pGlyphs():
for shape in glyph.shapes():
if len(shape.shapeData.name):
self.font_shapes.setdefault(shape.shapeData.name,
[]).append(glyph.name)
self.cmb_fontShapes.clear()
self.cmb_fontShapes.addItems(sorted(self.font_shapes.keys()))
def __init__(self, parentWidget):
super(TRCornerControl, self).__init__()
self.upper_widget = parentWidget
# - Init
self.active_font = pFont()
self.font_masters = self.active_font.masters()
self.sliders = []
self.process_glyphs = []
# - Widgets
self.__build()
def __init__(self):
super(tool_tab, self).__init__()
# - Init
self.active_font = pFont()
self.class_data = {}
# - Widgets
self.cmb_layer = QtGui.QComboBox()
self.cmb_layer.addItems(['All masters'] + self.active_font.masters())
self.btn_loadFile = QtGui.QPushButton('From File')
self.btn_loadFont = QtGui.QPushButton('From Font')
self.btn_saveExpr = QtGui.QPushButton('Save')
self.btn_loadExpr = QtGui.QPushButton('Load')
self.btn_exec = QtGui.QPushButton('Execute')
self.btn_help = QtGui.QPushButton('Help')
self.btn_classKern = QtGui.QPushButton('Class Kerning')
self.btn_classKern.setCheckable(True)
self.btn_loadFile.setCheckable(True)
self.btn_loadFont.setCheckable(True)
self.btn_loadFile.setChecked(False)
self.btn_loadFont.setChecked(False)
self.btn_classKern.setChecked(True)
self.btn_help.clicked.connect(lambda: QtGui.QMessageBox.information(None, 'Help', str_help))
self.btn_loadFile.clicked.connect(self.classes_fromFile)
self.btn_loadFont.clicked.connect(self.classes_fromFont)
self.btn_exec.clicked.connect(self.process)
self.btn_saveExpr.clicked.connect(self.expr_toFile)
self.btn_loadExpr.clicked.connect(self.expr_fromFile)
self.txt_editor = QtGui.QPlainTextEdit()
# - Build layouts
layoutV = QtGui.QGridLayout()
layoutV.addWidget(QtGui.QLabel('Class kerning data:'), 0, 0, 1, 4)
layoutV.addWidget(self.btn_loadFont, 1, 0, 1, 2)
layoutV.addWidget(self.btn_loadFile, 1, 2, 1, 2)
layoutV.addWidget(QtGui.QLabel('Process:'), 2, 0, 1, 4)
layoutV.addWidget(self.cmb_layer, 3, 0, 1, 2)
layoutV.addWidget(self.btn_classKern, 3, 2, 1, 2)
layoutV.addWidget(self.txt_editor, 5, 0, 30, 4)
layoutV.addWidget(self.btn_saveExpr, 36, 0, 1, 2)
layoutV.addWidget(self.btn_loadExpr, 36, 2, 1, 2)
layoutV.addWidget(self.btn_help, 37, 0, 1, 2)
layoutV.addWidget(self.btn_exec, 37, 2, 1, 2)
# - Set Widget
self.setLayout(layoutV)
def expr_fromFile(self):
self.active_font = pFont()
fontPath = os.path.split(self.active_font.fg.path)[0]
fname = QtGui.QFileDialog.getOpenFileName(
self.parentWgt, 'Load expressions from file', fontPath)
if fname != None:
with open(fname, 'r') as importFile:
self.txt_editor.setPlainText(importFile.read().decode('utf8'))
output(
6, app_name, 'Font:%s; Expressions loaded from: %s.' %
(self.active_font.name, fname))
def expr_toFile(self):
self.active_font = pFont()
fontPath = os.path.split(self.active_font.fg.path)[0]
fname = QtGui.QFileDialog.getSaveFileName(
self.parentWgt, 'Save expressions from file', fontPath, '*.txt')
if fname != None:
with open(fname, 'w') as importFile:
importFile.writelines(
self.txt_editor.toPlainText().encode('utf-8'))
output(
7, app_name, 'Font:%s; Expressions saved to: %s.' %
(self.active_font.name, fname))
def importExpr(self):
font = pFont()
fontPath = os.path.split(font.fg.path)[0]
fname = QtGui.QFileDialog.getOpenFileName(self,
'Open Metrics from file',
fontPath, '*.json')
with open(fname, 'r') as importFile:
self.srcGlyphBounds = json.load(importFile)
print 'LOAD:\t Font:%s; %s Glyph Metrics loaded from %s.' % (
font.name, len(self.srcGlyphBounds.keys()), fname)
print 'NOTE:\t Use < Pastes > to apply loaded!'
self.btn_pasteADV.setEnabled(True)
self.btn_pasteRSB.setEnabled(True)
def copy_bbox(self, copy_height=False):
dst_glyph = eGlyph()
if len(dst_glyph.selectedNodes()):
font = pFont()
src_glyph = font.glyph(self.edt_width.text)
adjPercent = self.spb_bbox_percent.value
adjUnits = self.spb_bbox_units.value
wLayers = dst_glyph._prepareLayers(pLayers)
for layer in wLayers:
selection = eNodesContainer(dst_glyph.selectedNodes(layer))
if copy_height:
dst_glyph_height = dst_glyph.getBounds(layer).height()
src_glyph_height = src_glyph.getBounds(layer).height()
dst_glyph_y = dst_glyph.getBounds(layer).y()
src_glyph_y = src_glyph.getBounds(layer).y()
process_shift = src_glyph_height * adjPercent / 100 - dst_glyph_height + adjUnits
process_y = src_glyph_y * adjPercent / 100 - dst_glyph_y + adjUnits
selection.shift(0, process_shift)
if process_y != 0:
selection = eNodesContainer(dst_glyph.nodes(layer))
selection.shift(0, process_y)
else:
dst_glyph_width = dst_glyph.getBounds(layer).width()
src_glyph_width = src_glyph.getBounds(layer).width()
process_shift = src_glyph_width * adjPercent / 100 - dst_glyph_width + adjUnits
selection.shift(process_shift, 0)
dst_glyph.updateObject(
dst_glyph.fl, 'Copy BBox | SRC: %s; DST: %s @ %s.' %
(src_glyph.name, dst_glyph.name, '; '.join(wLayers)))
dst_glyph.update()
else:
warnings.warn('Glyph: %s\tNo nodes selected.' % dst_glyph.name,
GlyphWarning)
def clear(self):
self.font = pFont()
self.glyphNames = baseGlyphset
self.edt_inputA.clear()
self.edt_inputB.clear()
self.cmb_inputA.clear()
self.cmb_inputB.clear()
self.cmb_inputA.addItems(sorted(self.glyphNames.keys()))
self.cmb_inputB.addItems(sorted(self.glyphNames.keys()))
self.edt_suffixA.clear()
self.edt_suffixB.clear()
self.edt_output.clear()
self.cmb_fillerPattern.clear()
self.cmb_fillerPattern.addItems(filler_patterns)
self.edt_sep.setText(glyphSep)
self.cmb_join.clear()
self.cmb_join.addItems(joinOpt.keys())
def generateOTGroups(self, toFile=False):
# - Init
temp_groups = self.font.kerning_groups_to_dict(layer=None,
byPosition=False,
sortUnicode=True)
kern_groups = {
groupName: groupData[0]
for groupName, groupData in temp_groups.items()
}
if toFile:
font_path = os.path.split(self.font.fg.path)[0]
save_path = QtGui.QFileDialog.getSaveFileName(
None, 'Save DTL Kern classes file', font_path,
file_formats['cla'])
if len(save_path):
with cla.CLAparser(save_path, 'w') as writer:
writer.dump(sorted(kern_groups.items()),
'Font: {}'.format(self.font.name))
output(
0, app_name, '{} kern classes exported! File: {}'.format(
len(kern_groups.keys()), save_path))
else:
gen_pattern = '@{0} = [{1}];'
self.font = pFont()
# - Generate
generatedString = [
gen_pattern.format(key, ' '.join(value))
for key, value in kern_groups.items()
]
self.edt_output.setText(
joinOpt[self.cmb_join.currentText].join(generatedString))
# - Copy to clipboard
clipboard = QtGui.QApplication.clipboard()
clipboard.setText(
joinOpt[self.cmb_join.currentText].join(generatedString))
output(
0, app_name,
'Generated string sent to clipboard.\tGroups: {}'.format(
len(generatedString)))
def setStem(self, horizontal=False):
font = pFont()
active_glyph = pGlyph()
selection = active_glyph.selectedNodes(None, True)
if horizontal:
stem_width = int(abs(selection[0].y - selection[-1].y))
else:
stem_width = int(abs(selection[0].x - selection[-1].x))
stem_name = '{}.{}:{}'.format(['V', 'H'][horizontal],
active_glyph.name, stem_width)
stem_type = self.cmb_select_stem.currentIndex
font.setStem(stem_width, stem_name, horizontal, stem_type)
font.updateObject(
font.fl, 'Set Stem(s): {}; {}; {}.'.format(
stem_name, stem_width, self.cmb_select_stem.currentText))
def glyph_duplicate(self):
copy_options = self.__getOptions()
# - Init
font = pFont()
process_glyphs = getProcessGlyphs(pMode)
processed_glyphs = []
for glyph in process_glyphs:
glyp_name = glyph.name
for n in range(self.spb_duplicate.value):
new_name = glyp_name + str(self.edt_glyphsuffix.text)
token_count = new_name.count(number_token)
if number_token in new_name:
new_name = new_name.replace('#' * token_count,
'%s') % fromat_number(
n, token_count)
if font.hasGlyph(new_name):
new_name = '%s.%s' % (new_name, str(n))
new_glyph = font.duplicateGlyph(glyp_name,
new_name,
dst_unicode=None,
options=copy_options)
for layer in new_glyph.layers():
new_transform, org_transform, rev_transform = self.tr_trans_ctrl.getTransform(
layer.boundingBox)
layer.applyTransform(org_transform)
layer.applyTransform(new_transform)
layer.applyTransform(rev_transform)
processed_glyphs.append(new_name)
'''
for glyph in process_glyphs:
wLayers = glyph._prepareLayers(pLayers)
'''
font.updateObject(
font.fl, 'Duplicate Glyph(s) | %s' % ', '.join(processed_glyphs))
def drop_guide_V(self):
font = pFont()
glyph = eGlyph()
src_glyph = glyph
src_name = self.edt_sourceName.text
if len(src_name) and font.hasGlyph(src_name):
src_glyph = font.glyph(src_name)
wLayers = glyph._prepareLayers(pLayers)
italicAngle = 0 #glyph.package.italicAngle_value
guide_name = self.edt_guideName.text if len(
self.edt_guideName.text) else '%s:%s:%s%%' % (
src_name, self.cmb_select_V.currentText, self.spb_prc_V.value)
for layerName in wLayers:
if 'BBox' in self.cmb_select_V.currentText:
width = src_glyph.layer(layerName).boundingBox.width()
origin = glyph.layer(layerName).boundingBox.x()
elif 'Adv' in self.cmb_select_V.currentText:
width = src_glyph.getAdvance(layerName)
origin = 0.
#print width, origin , width + origin, float(width)*self.spb_prc_V.value/100 + origin
guidePos = (float(width) * self.spb_prc_V.value / 100 + origin +
self.spb_unit_V.value, 0)
glyph.addGuideline(guidePos,
layer=layerName,
angle=italicAngle,
name=guide_name,
tag=self.edt_guideTag.text,
color=self.cmb_select_color.currentText)
glyph.updateObject(
glyph.fl,
'Drop Guide <%s> @ %s.' % (self.edt_guideName.text, '; '.join(
glyph._prepareLayers(pLayers))))
glyph.update()
def refresh(self):
# - Init
self.axis_points = []
self.axis_stems = []
self.data_glyphs = getProcessGlyphs(pMode)
self.data_glyphs = [glyph for glyph in self.data_glyphs if not glyph.isEmpty()]
self.glyph_arrays = {}
self.glyph_arrays_service = {}
self.active_glyph = eGlyph()
self.active_font = pFont()
self.active_workspace = pWorkspace()
self.active_canvas = self.active_workspace.getCanvas(True)
self.working_names = [glyph.name for glyph in self.data_glyphs] if len(self.data_glyphs) > 1 else [self.active_glyph.name]
self.lst_glyphName.clear()
self.lst_glyphName.addItems(self.working_names)
if len(self.active_font.masters()) > 1:
# - Activate
self.__lbl_warn.setText('')
self.__lbl_warn.setStyleSheet('')
self.btn_setAxis.setEnabled(True)
self.btn_getVstem.setEnabled(True)
self.btn_getHstem.setEnabled(True)
self.mixer_dx.reset()
self.mixer_dy.reset()
self.scalerX.reset()
self.scalerY.reset()
else:
# - Deactivate
self.__lbl_warn.show()
self.__lbl_warn.setText('<b>Insufficient number of Master layers!</b><br>Delta Panel is currently disabled!')
self.__lbl_warn.setStyleSheet('padding: 10; font-size: 10pt; background: lightpink;')
self.btn_setAxis.setEnabled(False)
self.btn_getVstem.setEnabled(False)
self.btn_getHstem.setEnabled(False)
def pasteExpr(self, sbMode=False):
font = pFont()
dstGlyphs = {glyph.name: glyph for glyph in font.pGlyphs()}
print 'WARN:\t Pasting Metrics to Font:%s;' % font.name
for glyphName, glyphMetrics in self.srcGlyphBounds.iteritems():
if glyphName in dstGlyphs:
wGlyph = dstGlyphs[glyphName]
if self.cmb_mode.currentIndex == 1:
for layer in wGlyph.masters():
if glyphMetrics.has_key(layer.name):
wGlyph.setLSB(glyphMetrics[layer.name][0],
layer.name)
if sbMode: # Paste RSB
wGlyph.setRSB(glyphMetrics[layer.name][1],
layer.name)
else: # Paste Advance
wGlyph.setAdvance(glyphMetrics[layer.name][2],
layer.name)
wGlyph.update()
print 'PASTE MM:\t Glyph: /%s;\tLayer: %s;\tValues(LSB, RSB, ADV): %s.' % (
glyphName, layer.name, glyphMetrics)
else:
print 'WARN:\t Glyph /%s - Layer %s not found!' % glyphName, layerName
else:
wGlyph.setLSB(glyphMetrics[0])
#wGlyph.setRSB(glyphMetrics[1])
wGlyph.setAdvance(glyphMetrics[2])
wGlyph.update()
print 'PASTE:\t Glyph: /%s;\tLayer: %s;\tValues(LSB, RSB, ADV): %s.' % (
glyphName, wGlyph.layer().name, glyphMetrics)
else:
print 'SKIP:\t Glyph /%s not found.' % glyphName
fl6.Update(CurrentFont())
def getProcessGlyphs(mode=0, font=None, workspace=None): '''Returns a list of glyphs for processing in TypeRig gui apps Args: mode (int): 0 - Current active glyph; 1 - All glyphs in current window; 2 - All selected glyphs; 3 - All glyphs in font font (fgFont) - Font file (object) workspace (flWorkspace) - Workspace Returns: list(eGlyph) ''' # - Init process_glyphs = [] active_workspace = pWorkspace() active_font = pFont(font) # - Collect process glyphs if mode == 0: process_glyphs.append(eGlyph()) if mode == 1: process_glyphs = [eGlyph(glyph) for glyph in active_workspace.getTextBlockGlyphs()] if mode == 2: process_glyphs = active_font.selectedGlyphs(extend=eGlyph) if mode == 3: process_glyphs = active_font.glyphs(extend=eGlyph) return process_glyphs
def __init__(self, parentWidget):
super(WFontMetrics, self).__init__()
# - Init
self.grid = QtGui.QGridLayout()
self.upperWidget = parentWidget
self.activeFont = pFont()
self.metricData = {}
self.refresh()
# - Interface
self.btn_apply = QtGui.QPushButton('Apply Changes')
self.btn_reset = QtGui.QPushButton('Reset')
self.btn_open = QtGui.QPushButton('Open')
self.btn_save = QtGui.QPushButton('Save')
self.btn_apply.clicked.connect(self.applyChanges)
self.btn_reset.clicked.connect(self.resetChanges)
self.btn_save.clicked.connect(self.exportMetrics)
self.btn_open.clicked.connect(self.importMetrics)
self.tab_fontMetrics = TRTableView(self.metricData)
# - Build
lbl_name = QtGui.QLabel('Font Metrics (All Masters)')
lbl_name.setMaximumHeight(20)
self.grid.addWidget(lbl_name, 0, 0, 1, 24)
self.grid.addWidget(self.tab_fontMetrics, 1, 0, 5, 21)
self.grid.addWidget(self.btn_save, 1, 21, 1, 3)
self.grid.addWidget(self.btn_open, 2, 21, 1, 3)
self.grid.addWidget(self.btn_reset, 4, 21, 1, 3)
self.grid.addWidget(self.btn_apply, 5, 21, 1, 3)
for i in range(1, 6):
self.grid.setRowStretch(i, 2)
self.setLayout(self.grid)
def moveElement(self, offset_x, offset_y, method):
# - Init
glyph = eGlyph()
font = pFont()
process_glyphs = getProcessGlyphs(pMode)
for glyph in process_glyphs:
wLayers = glyph._prepareLayers(pLayers)
for layer in wLayers:
selected_shapes = glyph.selectedAtShapes(index=False,
layer=layer,
deep=False)
for shape, contour, node in selected_shapes:
wShape = pShape(shape)
if method == 'Shift':
wShape.shift(offset_x, offset_y)
elif method == 'Scale':
wShape.scale(1. + offset_x / 100.,
1. + offset_y / 100.)
elif method == 'Shear':
wShape.shear(radians(offset_x), radians(offset_y))
glyph.update()
glyph.updateObject(
glyph.fl, 'Element: %s @ %s.' % (method, '; '.join(wLayers)))
# - Set Undo
#glyph.updateObject(glyph.activeLayer(), '%s @ %s.' %(method, glyph.activeLayer().name), verbose=False)
# - Finish it
glyph.update()
def reset(self):
self.audit_tree.clear()
self.audit_report = {}
self.active_font = pFont()
self.audit_report = OrderedDict(empty_record)
self.audit_tree.setTree(self.audit_report, self.header_names)
def __init__(self):
super(tool_tab, self).__init__()
# - Init
temp = pGlyph()
self.active_font = pFont()
layer_names = [layer.name for layer in temp.layers() if '#' not in layer.name]
# - Widgets
# -- Progress bar
self.progress = QtGui.QProgressBar()
self.progress.setMaximum(100)
# -- Report Tree
self.audit_report = OrderedDict(empty_record)
self.header_names = ['Glyph', 'Layers']
self.audit_tree = TRWAuditTree(self.audit_report, self.header_names)
self.audit_tree.selectionModel().selectionChanged.connect(self.auto_preview)
# -- Test List
temp_audit_glyph = auditGlyph(temp.fg, self.active_font.fg, self.audit_report)
audit_tests = [test.replace('_', ' ').replace('audit', '').title() for test in temp_audit_glyph.get_all_tests()]
self.audit_list = QtGui.QListWidget()
self.audit_list.setAlternatingRowColors(True)
self.audit_list.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
self.audit_list.addItems(audit_tests)
# -- Audit Options
self.cmb_layers = CheckableComboBox()
self.cmb_layers.addItems(['All Masters'] + layer_names)
self.cmb_reference = QtGui.QComboBox()
self.cmb_reference.addItems(layer_names)
if 'Regular' in layer_names:
self.cmb_reference.setCurrentIndex(layer_names.index('Regular'))
# -- Action Buttons
self.btn_audit_run = QtGui.QPushButton('Process Entire Font')
self.btn_audit_glyphs = QtGui.QPushButton('Process Glyph Selection')
self.btn_audit_tests = QtGui.QPushButton('Selected tests only')
self.btn_audit_reset = QtGui.QPushButton('Reset Record')
self.btn_audit_save = QtGui.QPushButton('Save Record')
self.btn_audit_select = QtGui.QPushButton('Auto Select Glyphs')
self.btn_select_cheked = QtGui.QPushButton('Select Checked Glyphs')
self.btn_audit_select.setCheckable(True)
self.btn_audit_tests.setCheckable(True)
self.btn_audit_select.setChecked(False)
self.btn_audit_tests.setChecked(True)
self.btn_audit_run.clicked.connect(lambda: self.process_audit(False))
self.btn_audit_glyphs.clicked.connect(lambda: self.process_audit(True))
self.btn_select_cheked.clicked.connect(lambda: self.selected_preview())
self.btn_audit_reset.clicked.connect(self.reset)
self.btn_audit_save.clicked.connect(self.save_audit)
# - Build Layout
lay_main = QtGui.QVBoxLayout()
lay_audit = QtGui.QGridLayout()
lay_audit.addWidget(self.btn_audit_tests, 0, 0, 1, 2)
lay_audit.addWidget(self.btn_audit_select, 0, 2, 1, 2)
lay_audit.addWidget(self.btn_select_cheked, 0, 4, 1, 2)
lay_audit.addWidget(self.btn_audit_save, 0, 6, 1, 2)
lay_audit.addWidget(self.btn_audit_reset, 0, 8, 1, 2)
lay_audit.addWidget(self.btn_audit_glyphs, 0, 10, 1, 2)
lay_audit.addWidget(self.btn_audit_run, 0, 12, 1, 4)
lay_audit.addWidget(QtGui.QLabel('Audit Tests:'), 1, 0, 1, 4)
lay_audit.addWidget(self.audit_list, 2, 0, 21, 4)
lay_audit.addWidget(QtGui.QLabel('Audit Report:'), 1, 4, 1, 12)
lay_audit.addWidget(self.audit_tree, 2, 4, 23, 12)
lay_audit.addWidget(QtGui.QLabel('Reference:'), 23, 0, 1, 1)
lay_audit.addWidget(self.cmb_reference, 23, 1, 1, 3)
lay_audit.addWidget(QtGui.QLabel('Audit on:'), 24, 0, 1, 1)
lay_audit.addWidget(self.cmb_layers, 24, 1, 1, 3)
lay_audit.addWidget(self.progress, 25, 0, 1, 16)
# - Finish
lay_main.addLayout(lay_audit)
self.setLayout(lay_main)
self.setMinimumSize(300, self.sizeHint.height())
def __add_names(self):
temp_font = pFont()
selection = [g.name for g in temp_font.selectedGlyphs()]
self.insertPlainText(' '.join(selection))
def process_insert(self):
# - Init
self.active_font = pFont()
current_glyph = eGlyph()
getUniGlyph = lambda c: self.active_font.fl.findUnicode(ord(
c)).name if all(['uni' not in c, '.' not in c, '_' not in c]
) else c
# - Parse input ------------------------------------------------------------
for line in self.txt_editor.toPlainText().splitlines():
# - Init
process_glyphs = {}
dst_store, src_store = [], []
w_layer = syn_passlayer # Pass all commands - no specific layer selected
if syn_insert in line and syn_comment not in line:
init_parse = line.split(syn_insert)
if len(init_parse) == 2: # No specific layer given
left, rigth = init_parse
elif len(init_parse) == 3: # Layer explicitly set
w_layer, left, rigth = init_parse
w_layer = w_layer.strip()
else:
output(2, app_name,
'Invalid syntax! Skipping Line: %s\n' % line)
continue
# - Set basics
#dst_store = [getUniGlyph(name) if syn_currglyph not in name else current_glyph.name for name in rigth.split()]
dst_store = [
name if syn_currglyph not in name else current_glyph.name
for name in rigth.split()
]
src_temp = [
item.strip().split(syn_pos) for item in left.split()
]
src_temp = [[item[0], item[1].split(syn_transform)]
if len(item) > 1 else item for item in src_temp]
process_glyphs = {glyph: src_temp for glyph in dst_store}
# - Process ------------------------------------------------------------
for glyph_name, insert_command in process_glyphs.iteritems():
# - Set working glyph
w_glyph = eGlyph(self.active_font.glyph(glyph_name).fl)
process_layers = w_glyph._prepareLayers(pLayers)
for layer in process_layers:
# - Process insertions
for insert in insert_command:
if len(insert):
# - Init
# -- Shape retrieval and origin determination
if len(insert[0]):
if syn_bboxBL in insert[
0]: # Shape origin: measured at Shapes BBox Bottom Left
insert_name = insert[0].replace(
syn_bboxBL, '')
w_shape = self.active_font.findShape(
insert_name, layer)
insert_origin = Coord(
w_shape.boundingBox.x(),
w_shape.boundingBox.y())
elif syn_bboxBR in insert[
0]: # Shape origin: measured at Shapes BBox Bottom Right
insert_name = insert[0].replace(
syn_bboxBR, '')
w_shape = self.active_font.findShape(
insert_name, layer)
insert_origin = Coord(
w_shape.boundingBox.x() +
w_shape.boundingBox.width(),
w_shape.boundingBox.y())
elif syn_bboxTL in insert[
0]: # Shape origin: measured at Shapes BBox Top Left
insert_name = insert[0].replace(
syn_bboxTL, '')
w_shape = self.active_font.findShape(
insert_name, layer)
insert_origin = Coord(
w_shape.boundingBox.x(),
w_shape.boundingBox.y() +
w_shape.boundingBox.height())
elif syn_bboxTR in insert[
0]: # Shape origin: measured at Shapes BBox Top Right
insert_name = insert[0].replace(
syn_bboxTR, '')
w_shape = self.active_font.findShape(
insert_name, layer)
insert_origin = Coord(
w_shape.boundingBox.x() +
w_shape.boundingBox.height(),
w_shape.boundingBox.y() +
w_shape.boundingBox.width())
elif syn_label in insert[
0]: # Shape origin: At source Glyphs Labeled Node
insert_name, node_label = insert[
0].split(syn_label)
for glyph in self.active_font.pGlyphs(
):
w_shape = glyph.findShape(
insert_name, layer)
if w_shape is not None:
insert_origin = Coord(
glyph.findNodeCoords(
node_label, layer))
break
else: # Shape origin: Not set
insert_name = insert[0]
w_shape = self.active_font.findShape(
insert_name, layer)
insert_origin = Coord(0, 0)
else:
output(
2, app_name,
'Invalid command! Skipping insertion command: %s\n'
% insert)
continue
# -- In-glyph positioning
insert_position = None
if len(
insert
) == 1: # Position: Simplest case no positional tags
insert_coord = Coord((0, 0))
else:
if len(insert[1]):
w_bbox = w_glyph.getBounds(layer)
if syn_currnode == insert[1][
0]: # Position: Destination Glyphs Currently selected node
position = w_glyph.selectedCoords(
layer, applyTransform=True)
insert_position = position[
0] if len(position) else None
elif syn_bboxBL == insert[1][
0]: # Position: Destination Glyphs BBox Bottom Left
insert_position = (w_bbox.x(),
w_bbox.y())
elif syn_bboxBR == insert[1][
0]: # Position: Destination Glyphs BBox Bottom Right
insert_position = (w_bbox.x() +
w_bbox.width(),
w_bbox.y())
elif syn_bboxTL == insert[1][
0]: # Position: Destination Glyphs BBox Top Left
insert_position = (w_bbox.x(),
w_bbox.y() +
w_bbox.height())
elif syn_bboxTR == insert[1][
0]: # Position: Destination Glyphs BBox Top Right
insert_position = (w_bbox.x() +
w_bbox.height(),
w_bbox.y() +
w_bbox.width())
elif syn_label in insert[1][
0]: # Position: Destination Glyphs Labeled Node
insert_position = w_glyph.findNodeCoords(
insert[1][0].strip(syn_label),
layer)
elif syn_anchor in insert[1][
0]: # Position: Destination Glyphs Anchor
insert_position = w_glyph.findAnchorCoords(
insert[1][0].strip(syn_anchor),
layer)
elif syn_coordsep in insert[1][
0]: # Position: Destination Glyphs Coordinates
insert_position = eval(
'(%s)' % insert[1][0])
if len(
insert[1]
) > 1: # Positional correction in format (x,y)
insert_correction = Coord(
eval('(%s)' % insert[1][1]))
else:
insert_correction = Coord((0, 0))
if insert_position is None:
output(
2, app_name,
'Invalid positional tags! Skipping insertion command: %s\n'
% insert)
continue
# - Set insertion coordinates
insert_coord = Coord(
insert_position) + insert_correction
# - Insert and reposition
# !!! A quirky way of adding shapes follows
# !!! This is so very wrong - adding the shape twice and removing the first,
# !!! forces FL to make a proper clone of the shape!?
temp_shape = w_glyph.addShape(
w_shape, layer) # A dummy that helps ??!
new_shape = w_glyph.addShape(w_shape, layer)
w_glyph.layer(layer).removeShape(temp_shape)
new_shape.assignStyle(
w_shape
) # The only way to copy the 'non-spacing' property for now
new_position = insert_coord - insert_origin
new_transform = QtGui.QTransform(
1, 0, 0, 0, 1, 0, new_position.x,
new_position.y, 1)
new_shape.transform = new_transform
w_glyph.update()
# - Finish
w_glyph.updateObject(
w_glyph.fl,
'Shapes inserted to glyph: %s' % w_glyph.name)
output(0, app_name, 'Glyphs processed: %s' % ' '.join(dst_store))
