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))