├── Lib └── glyphNameFormatter │ ├── test │ ├── __init__.py │ ├── testFindArabDiacritics.py │ ├── testMathGreeks.py │ ├── testAGDcoverage.py │ └── checkWhichArabicNamesHavePresentationForms.py │ ├── names │ └── ranges │ │ ├── 0E000-0F8FF private_use_area.txt │ │ ├── 0FFF0-0FFFF specials.txt │ │ ├── 02440-0245F optical_character_recognition.txt │ │ ├── 0FE10-0FE1F vertical_forms.txt │ │ ├── 020A0-020CF currency_symbols.txt │ │ ├── 0FE50-0FE6F small_form_variants.txt │ │ ├── 01380-0139F ethiopic_supplement.txt │ │ ├── 0AB00-0AB2F ethiopic_extended-a.txt │ │ ├── 1E7E0-1E7FF ethiopic_extended-b.txt │ │ ├── 03100-0312F bopomofo.txt │ │ ├── 02C60-02C7F latin_extended-c.txt │ │ ├── 02D00-02D2F georgian_supplement.txt │ │ ├── 02580-0259F block_elements.txt │ │ ├── 02070-0209F superscripts_and_subscripts.txt │ │ ├── 020D0-020FF combining_diacritical_marks_for_symbols.txt │ │ ├── 02400-0243F control_pictures.txt │ │ ├── 0FE30-0FE4F cjk_compatibility_forms.txt │ │ ├── 1F000-1F02F mahjong_tiles.txt │ │ ├── 01C90-01CBF georgian_extended.txt │ │ ├── 00500-0052F cyrillic_supplement.txt │ │ ├── 00B80-00BFF tamil.txt │ │ ├── 027C0-027EF miscellaneous_mathematical_symbols-a.txt │ │ ├── 01CD0-01CFF vedic_extensions.txt │ │ ├── 02150-0218F number_forms.txt │ │ ├── 00000-0007F basic_latin.txt │ │ ├── 00A00-00A7F gurmukhi.txt │ │ ├── 02100-0214F letterlike_symbols.txt │ │ ├── 0FB00-0FB4F alphabetic_presentation_forms.txt │ │ ├── 02D80-02DDF ethiopic_extended.txt │ │ ├── 013A0-013FF cherokee.txt │ │ ├── 00B00-00B7F oriya.txt │ │ ├── 0AB30-0AB6F latin_extended-e.txt │ │ ├── 03000-0303F cjk_symbols_and_punctuation.txt │ │ ├── 01DC0-01DFF combining_diacritical_marks_supplement.txt │ │ ├── 010A0-010FF georgian.txt │ │ └── 00E00-00E7F thai.txt │ ├── rangeProcessors │ ├── __init__.py │ ├── block_elements.py │ ├── private_use_area.py │ ├── latin_extended_f.py │ ├── geometric_shapes_extended.py │ ├── symbols_and_pictographs_extended_a.py │ ├── georgian_extended.py │ ├── domino_tiles.py │ ├── miscellaneous_symbols_and_arrows.py │ ├── miscellaneous_mathematical_symbols_b.py │ ├── supplemental_mathematical_operators.py │ ├── _template.py │ ├── mahjong_tiles.py │ ├── transport_and_map_symbols.py │ ├── emoticons.py │ ├── georgian_supplement.py │ ├── optical_character_recognition.py │ ├── specials.py │ ├── bopomofo.py │ ├── braille_patterns.py │ ├── cherokee.py │ ├── hangul_compatibility_jamo.py │ ├── runic.py │ ├── helper_numbers.py │ ├── playing_cards.py │ ├── control_pictures.py │ ├── currency_symbols.py │ ├── helper_arabic_positions.py │ ├── ethiopic_extended_a.py │ ├── glagolitic.py │ ├── phonetic_extensions_supplement.py │ ├── soyombo.py │ ├── thai.py │ ├── cherokee_supplement.py │ ├── ethiopic_extended.py │ ├── ethiopic_extended_b.py │ ├── gurmukhi.py │ ├── katakana.py │ ├── tamil.py │ ├── ethiopic_supplement.py │ ├── hangul_jamo.py │ ├── oriya.py │ ├── ethiopic.py │ ├── greek_extended.py │ ├── small_form_variants.py │ ├── zanabazar_square.py │ ├── vedic_extensions.py │ ├── cyrillic_supplement.py │ ├── telugu.py │ ├── enclosed_alphanumerics.py │ ├── javanese.py │ ├── vertical_forms.py │ ├── helper_indic.py │ ├── mongolian.py │ ├── malayalam.py │ ├── number_forms.py │ ├── superscripts_and_subscripts.py │ ├── hiragana.py │ ├── combining_diacritical_marks_for_symbols.py │ ├── supplemental_arrows_b.py │ ├── supplemental_arrows_c.py │ ├── gujarati.py │ ├── latin_extended_c.py │ ├── kannada.py │ ├── bengali.py │ ├── georgian.py │ ├── box_drawing.py │ ├── combining_diacritical_marks_supplement.py │ ├── latin_extended_additional.py │ ├── miscellaneous_mathematical_symbols_a.py │ ├── alphabetic_presentation_forms.py │ ├── cjk_compatibility_forms.py │ ├── enclosed_alphanumeric_supplement.py │ ├── cjk_symbols_and_punctuation.py │ ├── halfwidth_and_fullwidth_forms.py │ ├── letterlike_symbols.py │ ├── enclosed_cjk_letters_and_months.py │ ├── arabic_presentation_forms_b.py │ ├── helper_greek_diacritics.py │ ├── arabic_presentation_forms_a.py │ ├── general_punctuation.py │ ├── mathematical_alphanumeric_symbols.py │ ├── latin_extended_e.py │ ├── tibetan.py │ ├── geometric_shapes.py │ ├── armenian.py │ ├── arabic_supplement.py │ ├── miscellaneous_symbols.py │ ├── helper_shapes.py │ ├── devanagari.py │ ├── chess_symbols.py │ ├── supplemental_punctuation.py │ ├── mathematical_operators.py │ ├── ipa_extensions.py │ ├── helper_latin_greeks.py │ ├── helper_arabic_ligature_exceptions.py │ ├── spacing_modifier_letters.py │ ├── basic_latin.py │ ├── latin_extended_b.py │ ├── latin_extended_a.py │ ├── miscellaneous_technical.py │ ├── latin_extended_d.py │ ├── miscellaneous_symbols_and_pictographs.py │ ├── phonetic_extensions.py │ ├── helper_digit_names.py │ ├── latin_1_supplement.py │ ├── dingbats.py │ ├── cyrillic.py │ └── hebrew.py │ ├── data │ ├── test_germans.py │ ├── scriptConflictNames.py │ └── buildFlatUnicodeList.py │ ├── exporters │ ├── exportRangeOverviews.py │ └── exportGlyphData.py │ └── tools.py ├── banner.png ├── pyproject.toml ├── .github └── FUNDING.yml ├── TIL about fontTools.unicodedata.py ├── todo.md ├── script_info_from_fonttools.py ├── glyphNameFormatterBanner.py ├── changes_to_gnufl ├── .gitignore ├── banner.svg ├── setup.py └── LICENSE /Lib/glyphNameFormatter/test/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: UTF-8 -*- 2 | -------------------------------------------------------------------------------- /banner.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LettError/glyphNameFormatter/HEAD/banner.png -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/0E000-0F8FF private_use_area.txt: -------------------------------------------------------------------------------- 1 | # Private Use Area 0E000 - 0F8FF -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [build-system] 2 | requires = ["setuptools"] 3 | build-backend = "setuptools.build_meta" 4 | -------------------------------------------------------------------------------- /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | # These are supported funding model platforms 2 | 3 | github: [letterror, typemytype] 4 | -------------------------------------------------------------------------------- /TIL about fontTools.unicodedata.py: -------------------------------------------------------------------------------- 1 | from fontTools.unicodedata import script 2 | f = CurrentFont() 3 | for g in f: 4 | if g.unicode is not None: 5 | print(g.name, g.unicode, script(g.unicode)) 6 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: UTF-8 -*- 2 | # default, final, catchall handler 3 | 4 | 5 | def process(self): 6 | self.condense(self.uniName) 7 | return False 8 | 9 | -------------------------------------------------------------------------------- /todo.md: -------------------------------------------------------------------------------- 1 | # API 2 | 3 | ## Build small api around an exported list 4 | 5 | * lookup glyphName 6 | * lookup unicode 7 | * lookup unicode name 8 | * lookup components?? 9 | * search through: I want all glyphs with a `grave` 10 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/block_elements.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.camelCase() 4 | self.compress() 5 | 6 | if __name__ == "__main__": 7 | from glyphNameFormatter.exporters import printRange 8 | printRange("Block Elements") 9 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/private_use_area.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.uniNameProcessed = "private_use_%04X"%self.uniNumber 4 | 5 | if __name__ == "__main__": 6 | from glyphNameFormatter.exporters import printRange 7 | printRange("Private Use Area") 8 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/latin_extended_f.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.handleCase() 4 | self.camelCase() 5 | 6 | 7 | if __name__ == "__main__": 8 | from glyphNameFormatter.exporters import printRange 9 | printRange("Latin Extended-F") 10 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/geometric_shapes_extended.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("-", '') 4 | self.camelCase() 5 | 6 | if __name__ == "__main__": 7 | from glyphNameFormatter.exporters import printRange 8 | printRange("Geometric Shapes Extended") 9 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/symbols_and_pictographs_extended_a.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("-", " ") 4 | self.camelCase() 5 | 6 | if __name__ == "__main__": 7 | from glyphNameFormatter.exporters import printRange 8 | printRange("Symbols and Pictographs Extended-A") 9 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/georgian_extended.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("MTAVRULI", "Geor") #Mtavruli 4 | self.processAs("Georgian") 5 | 6 | 7 | if __name__ == "__main__": 8 | from glyphNameFormatter.exporters import printRange 9 | printRange("Georgian Extended") 10 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/domino_tiles.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("TILE") 5 | self.replace("-", "_") 6 | self.lower() 7 | self.compress() 8 | 9 | if __name__ == "__main__": 10 | from glyphNameFormatter.test import printRange 11 | printRange("Domino Tiles") 12 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/miscellaneous_symbols_and_arrows.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("-", " ") 4 | self.camelCase() 5 | 6 | 7 | if __name__ == "__main__": 8 | from glyphNameFormatter.exporters import printRange 9 | printRange("Miscellaneous Symbols and Arrows") 10 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/miscellaneous_mathematical_symbols_b.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("-", " ") 4 | self.camelCase() 5 | 6 | 7 | if __name__ == "__main__": 8 | from glyphNameFormatter.exporters import printRange 9 | printRange("Miscellaneous Mathematical Symbols-B") 10 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/supplemental_mathematical_operators.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("-", " ") 4 | self.camelCase() 5 | 6 | 7 | if __name__ == "__main__": 8 | from glyphNameFormatter.exporters import printRange 9 | printRange("Supplemental Mathematical Operators") 10 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/_template.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.setExperimental() 4 | #self.edit("TAMIL") 5 | #self.edit("LETTER") 6 | pass 7 | 8 | 9 | if __name__ == "__main__": 10 | from glyphNameFormatter.exporters import printRange 11 | printRange("<--RANGE NAME-->") 12 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/mahjong_tiles.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("Characters") 4 | self.edit("MAHJONG TILE", "Mahjong") 5 | self.camelCase() 6 | 7 | 8 | if __name__ == "__main__": 9 | from glyphNameFormatter.exporters import printRange 10 | printRange("Mahjong Tiles") 11 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/transport_and_map_symbols.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("SYMBOL") 4 | self.replace("-", " ") 5 | self.camelCase() 6 | pass 7 | 8 | 9 | if __name__ == "__main__": 10 | from glyphNameFormatter.exporters import printRange 11 | printRange("Transport and Map Symbols") 12 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/emoticons.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | # just to test unicode 8 stuff 5 | # not complete 6 | self.replace("-", " ") 7 | self.camelCase() 8 | self.compress() 9 | 10 | if __name__ == "__main__": 11 | from glyphNameFormatter.exporters import printRange 12 | printRange("Emoticons") 13 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/georgian_supplement.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.processAs("Georgian") 4 | if self.has("GEORGIAN SMALL LETTER"): 5 | self.suffix("Geok") #Nuskhuri 6 | 7 | 8 | if __name__ == "__main__": 9 | from glyphNameFormatter.exporters import printRange 10 | printRange("Georgian Supplement") 11 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/0FFF0-0FFFF specials.txt: -------------------------------------------------------------------------------- 1 | # Specials 0FFF0 - 0FFFF 2 | FFF9 interlinearanchor INTERLINEAR ANNOTATION ANCHOR 3 | FFFA interlinearseparator INTERLINEAR ANNOTATION SEPARATOR 4 | FFFB interlinearterminator INTERLINEAR ANNOTATION TERMINATOR 5 | FFFC replacementcharobj OBJECT REPLACEMENT CHARACTER 6 | FFFD replacementchar REPLACEMENT CHARACTER -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/optical_character_recognition.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("OCR") 5 | self.edit("DOUBLE", "dbl") 6 | self.lower() 7 | self.compress() 8 | 9 | if __name__ == "__main__": 10 | from glyphNameFormatter.exporters import printRange 11 | printRange("Optical Character Recognition") 12 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/specials.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("ANNOTATION") 5 | self.edit("CHARACTER", "char") 6 | self.edit("OBJECT", "obj") 7 | self.lower() 8 | self.compress() 9 | 10 | if __name__ == "__main__": 11 | from glyphNameFormatter.exporters import printRange 12 | printRange("Specials") 13 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/bopomofo.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | # edits go here 5 | self.edit("BOPOMOFO") 6 | self.edit("LETTER") 7 | self.lower() 8 | self.compress() 9 | self.scriptPrefix() 10 | 11 | if __name__ == "__main__": 12 | from glyphNameFormatter.exporters import printRange 13 | printRange("Bopomofo") 14 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/braille_patterns.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("BRAILLE PATTERN BLANK", "brblank") 4 | self.replace("BRAILLE PATTERN DOTS", "dots") 5 | self.replace("-", "") 6 | 7 | 8 | if __name__ == "__main__": 9 | from glyphNameFormatter.exporters import printRange 10 | printRange("Braille Patterns") 11 | -------------------------------------------------------------------------------- /script_info_from_fonttools.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | from fontTools.unicodedata import script 5 | from pprint import pprint 6 | 7 | f = CurrentFont() 8 | 9 | scrpts = {} 10 | for g in f: 11 | if g.unicode is not None: 12 | s = script(g.unicode) 13 | if s not in scrpts: 14 | scrpts[s] = [] 15 | scrpts[s].append(g.name) 16 | pprint(scrpts) -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/cherokee.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.setDraft() 4 | self.edit("CHEROKEE") 5 | self.edit("LETTER") 6 | self.edit("SMALL", "small") 7 | self.lower() 8 | self.scriptPrefix() 9 | 10 | 11 | if __name__ == "__main__": 12 | from glyphNameFormatter.exporters import printRange 13 | printRange("Cherokee") 14 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/hangul_compatibility_jamo.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("HANGUL") 5 | self.edit("LETTER") 6 | self.edit("-") 7 | self.lower() 8 | self.compress() 9 | self.scriptPrefix() 10 | 11 | if __name__ == "__main__": 12 | from glyphNameFormatter.exporters import printRange 13 | printRange("Hangul Compatibility Jamo") 14 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/runic.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.setDraft() 4 | self.edit("RUNIC") 5 | self.edit("LETTER") 6 | self.scriptPrefix() 7 | self.replace("-", "_") 8 | self.replace(" ", "_") 9 | self.compress() 10 | self.lower() 11 | 12 | if __name__ == "__main__": 13 | from glyphNameFormatter.exporters import printRange 14 | printRange("Runic") 15 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/helper_numbers.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("0", "zero") 4 | self.replace("1", "one") 5 | self.replace("2", "two") 6 | self.replace("3", "three") 7 | self.replace("4", "four") 8 | self.replace("5", "five") 9 | self.replace("6", "six") 10 | self.replace("7", "seven") 11 | self.replace("8", "eight") 12 | self.replace("9", "nine") -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/playing_cards.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | # processor for rangeName 5 | self.setDraft() 6 | 7 | self.edit("PLAYING CARD") 8 | self.edit("-") 9 | self.lower() 10 | self.compress() 11 | self.scriptPrefix() 12 | 13 | 14 | if __name__ == "__main__": 15 | from glyphNameFormatter.exporters import printRange 16 | printRange("Playing Cards") 17 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/control_pictures.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("SYMBOL") 5 | self.replace("FORM", "form") 6 | self.edit("FOR") 7 | self.edit("TABULATION", "tab") 8 | self.lower() 9 | self.compress() 10 | self.scriptPrefix() 11 | 12 | if __name__ == "__main__": 13 | from glyphNameFormatter.exporters import printRange 14 | printRange("Control Pictures") 15 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/currency_symbols.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("EURO-CURRENCY", "euroarchaic") 4 | self.replace("EURO", "Euro") 5 | self.replace("SIGN") 6 | self.compress() 7 | if not self.has("EURO"): 8 | self.lower() 9 | 10 | 11 | if __name__ == "__main__": 12 | from glyphNameFormatter.exporters import printRange 13 | printRange("Currency Symbols") 14 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/helper_arabic_positions.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | 4 | # positions 5 | self.edit('INITIAL FORM', ".init") 6 | self.edit('MEDIAL FORM', ".medi") 7 | self.edit('FINAL FORM', ".fina") 8 | self.edit('ISOLATED FORM', ".isol") 9 | 10 | if __name__ == "__main__": 11 | from glyphNameFormatter.exporters import printRange 12 | printRange("Helper Arabic Positions") 13 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/ethiopic_extended_a.py: -------------------------------------------------------------------------------- 1 | def process(self): 2 | self.edit("ETHIOPIC") 3 | self.edit("SYLLABLE") 4 | self.edit("TONAL") 5 | self.editToFinal("MARK", "mark") 6 | self.lower() 7 | self.compress() 8 | self.scriptPrefix() 9 | 10 | 11 | if __name__ == "__main__": 12 | from glyphNameFormatter.exporters import printRange 13 | 14 | printRange("Ethiopic Extended-A") 15 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/data/test_germans.py: -------------------------------------------------------------------------------- 1 | #unicode 12 2 | lowercase = "00DF 0053 0053 Ll LATIN SMALL LETTER SHARP S" 3 | uppercase = "1E9E 00DF Lu LATIN CAPITAL LETTER SHARP S" 4 | 5 | lines = [lowercase, uppercase] 6 | for line in lines: 7 | uniNumber, uniUppercase, uniLowercase, uniCategory, mathFlag, uniName, = line.split("\t") 8 | print(f"uniNumber:{uniNumber}, uniUppercase:{uniUppercase}, uniLowercase:{uniLowercase}, uniName:{uniName}") 9 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/glagolitic.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | 4 | # handle conflict with Yu Arabic 5 | if self.uniNumber == 0x2C53: 6 | self.forceScriptPrefix("Glagolitic") 7 | 8 | self.edit("GLAGOLITIC") 9 | 10 | 11 | self.handleCase() 12 | self.compress() 13 | 14 | if __name__ == "__main__": 15 | from glyphNameFormatter.exporters import printRange 16 | printRange("Glagolitic") 17 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/phonetic_extensions_supplement.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | # edits go here 5 | self.edit("CROSSED-TAIL", "crossedtail") 6 | self.edit("WITH HOOK AND TAIL", "hooktail") 7 | self.processAs("Phonetic Extensions") 8 | self.compress() 9 | 10 | if __name__ == "__main__": 11 | from glyphNameFormatter.exporters import printRange 12 | printRange("Phonetic Extensions Supplement") 13 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/soyombo.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("CLUSTER-INITIAL", "ClusterInitial") 4 | self.edit("SOYOMBO LETTER", "") 5 | self.edit("SOYOMBO VOWEL SIGN", "VowelSign") 6 | self.edit("SOYOMBO", "") 7 | self.camelCase() 8 | self.forceScriptPrefix("Soyombo") 9 | 10 | if __name__ == "__main__": 11 | from glyphNameFormatter.exporters import printRange 12 | printRange("Soyombo") 13 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/thai.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("THAI") 4 | self.edit("CHARACTER") 5 | self.edit("CURRENCY") 6 | self.edit("SYMBOL") 7 | self.edit("DIGIT") 8 | self.processAs("Helper Digit Names") 9 | self.lower() 10 | self.compress() 11 | self.scriptPrefix() 12 | 13 | if __name__ == "__main__": 14 | from glyphNameFormatter.exporters import printRange 15 | printRange("Thai") 16 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/cherokee_supplement.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.setDraft() 4 | self.edit("CHEROKEE") 5 | self.edit("LETTER") 6 | self.edit("SMALL", "small") 7 | self.lower() 8 | self.scriptPrefix() 9 | 10 | 11 | if __name__ == "__main__": 12 | from glyphNameFormatter.exporters import printRange 13 | from glyphNameFormatter.tools import debug 14 | printRange("Cherokee Supplement") 15 | debug(0xAB70) -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/ethiopic_extended.py: -------------------------------------------------------------------------------- 1 | def process(self): 2 | self.edit("ETHIOPIC") 3 | self.edit("SYLLABLE") 4 | self.edit("GLOTTAL", "glottal") 5 | self.edit("TONAL") 6 | self.editToFinal("MARK", "mark") 7 | self.lower() 8 | self.compress() 9 | self.scriptPrefix() 10 | 11 | 12 | if __name__ == "__main__": 13 | from glyphNameFormatter.exporters import printRange 14 | 15 | printRange("Ethiopic Extended") 16 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/ethiopic_extended_b.py: -------------------------------------------------------------------------------- 1 | def process(self): 2 | self.edit("ETHIOPIC") 3 | self.edit("SYLLABLE") 4 | self.edit("TONAL") 5 | self.edit("GURAGE", "gurage") 6 | self.editToFinal("MARK", "mark") 7 | self.lower() 8 | self.compress() 9 | self.scriptPrefix() 10 | 11 | 12 | if __name__ == "__main__": 13 | from glyphNameFormatter.exporters import printRange 14 | 15 | printRange("Ethiopic Extended-B") 16 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/gurmukhi.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("GURMUKHI") 4 | self.edit("LETTER") 5 | self.edit("DIGIT") 6 | self.processAs("Helper Indic") 7 | self.processAs("Helper Numbers") 8 | self.edit("SIGN", "sign") 9 | self.lower() 10 | self.compress() 11 | self.scriptPrefix() 12 | 13 | if __name__ == "__main__": 14 | from glyphNameFormatter.exporters import printRange 15 | printRange("Gurmukhi") 16 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/katakana.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("KATAKANA-HIRAGANA", "kana") 4 | self.edit("SOUND MARK") 5 | self.edit("MARK") 6 | self.edit("LETTER") 7 | self.edit("SMALL", "small") 8 | self.edit("KATAKANA") 9 | self.lower() 10 | self.compress() 11 | self.scriptPrefix() 12 | 13 | if __name__ == "__main__": 14 | from glyphNameFormatter.exporters import printRange 15 | printRange("Katakana") 16 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/tamil.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("TAMIL") 4 | self.edit("LETTER") 5 | self.edit("DIGIT") 6 | self.edit("NUMBER") 7 | self.processAs("Helper Indic") 8 | self.processAs("Helper Numbers") 9 | self.replace("-") 10 | self.lower() 11 | self.compress() 12 | self.scriptPrefix() 13 | 14 | if __name__ == "__main__": 15 | from glyphNameFormatter.exporters import printRange 16 | printRange("Tamil") 17 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/ethiopic_supplement.py: -------------------------------------------------------------------------------- 1 | def process(self): 2 | self.edit("ETHIOPIC") 3 | self.edit("SYLLABLE") 4 | self.edit("TONAL") 5 | self.edit("MARK") 6 | self.editToFinal("SEBATBEIT", "sebatbeit") 7 | self.edit("-") 8 | self.lower() 9 | self.compress() 10 | self.scriptPrefix() 11 | 12 | 13 | if __name__ == "__main__": 14 | from glyphNameFormatter.exporters import printRange 15 | 16 | printRange("Ethiopic Supplement") 17 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/hangul_jamo.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("HANGUL") 4 | self.edit("CHOSEONG", "choseong") 5 | self.edit("JONGSEONG", "jongseong") 6 | self.edit("JUNGSEONG", "jungseong") 7 | self.lower() 8 | self.replace("o-e", "o_e") # ? 9 | self.replace("-") 10 | self.compress() 11 | self.scriptPrefix() 12 | 13 | if __name__ == "__main__": 14 | from glyphNameFormatter.exporters import printRange 15 | printRange("Hangul Jamo") 16 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/oriya.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("ORIYA") 4 | self.edit("LETTER") 5 | self.edit("VOWEL SIGN", "sign") 6 | self.edit("DIGIT") 7 | self.edit("FRACTION") 8 | self.processAs("Helper Indic") 9 | self.processAs("Helper Numbers") 10 | 11 | 12 | self.lower() 13 | self.compress() 14 | self.scriptPrefix() 15 | 16 | if __name__ == "__main__": 17 | from glyphNameFormatter.exporters import printRange 18 | printRange("Oriya") 19 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/ethiopic.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | pass 4 | self.edit("ETHIOPIC") 5 | self.edit("SYLLABLE") 6 | self.edit("GLOTTAL", "glottal") 7 | self.processAs("Helper Digit Names") 8 | self.edit("NUMBER") 9 | self.edit("DIGIT") 10 | self.edit("COMBINING", "cmb") 11 | self.lower() 12 | self.compress() 13 | self.scriptPrefix() 14 | 15 | if __name__ == "__main__": 16 | from glyphNameFormatter.exporters import printRange 17 | printRange("Ethiopic") 18 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/greek_extended.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("GREEK PROSGEGRAMMENI", "iotaadscript") 4 | self.processAs("Greek and Coptic") 5 | self.compress() 6 | 7 | if __name__ == "__main__": 8 | from glyphNameFormatter.exporters import printRange 9 | printRange("Greek Extended") 10 | 11 | # https://github.com/LettError/glyphNameFormatter/issues/38 12 | from glyphNameFormatter import GlyphName 13 | g = GlyphName(0x1FBE) 14 | assert g.getName() == "iotaadscript" -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/02440-0245F optical_character_recognition.txt: -------------------------------------------------------------------------------- 1 | # Optical Character Recognition 02440 - 0245F 2 | 2440 ocr:hook OCR HOOK 3 | 2441 ocr:chair OCR CHAIR 4 | 2442 fork OCR FORK 5 | 2443 invertedfork OCR INVERTED FORK 6 | 2444 beltbuckle OCR BELT BUCKLE 7 | 2445 ocr:bowtie OCR BOW TIE 8 | 2446 branchbankidentification OCR BRANCH BANK IDENTIFICATION 9 | 2447 amountofcheck OCR AMOUNT OF CHECK 10 | 2448 ocr:dash OCR DASH 11 | 2449 customeraccountnumber OCR CUSTOMER ACCOUNT NUMBER 12 | 244A backslashdbl OCR DOUBLE BACKSLASH -------------------------------------------------------------------------------- /glyphNameFormatterBanner.py: -------------------------------------------------------------------------------- 1 | size(1600,451) 2 | for n in installedFonts(): 3 | if n.find("Microgramma")!=-1: 4 | print(n) 5 | 6 | ss = 188 7 | ss2 = 192 8 | ss3 = 177.4 9 | f = 0.74 10 | f2 = 0.8 11 | fill(1,.2,.2) 12 | rect(0,0,width(), height()) 13 | fill(1) 14 | fontSize(ss) 15 | font("MicrogrammaCom-BoldExtended") 16 | text("GLYPHNAME", (10,height()-140)) 17 | text("FORMATTER", (10,height()-280)) 18 | fontSize(ss2) 19 | fill(1,.8, 0,.9) 20 | text("unicode16", (10,20)) 21 | 22 | saveImage("banner.png") 23 | saveImage("banner.svg") -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/small_form_variants.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.data.scriptPrefixes import scriptPrefixes 2 | 3 | 4 | def process(self): 5 | self.edit("SMALL") 6 | self.edit("IDEOGRAPHIC", "ideographic") 7 | self.processAs("Basic Latin") 8 | self.processAs("General Punctuation") 9 | self.scriptTag = scriptPrefixes["Small Form Variants"] 10 | self.suffix("small") 11 | 12 | if __name__ == "__main__": 13 | from glyphNameFormatter.exporters import printRange 14 | printRange("Small Form Variants") 15 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/zanabazar_square.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("LETTER") 4 | self.edit("SQUARE") 5 | self.edit("ZANABAZAR") 6 | self.edit("-A", 'dashA') 7 | self.edit("DOUBLE-LINED", 'dbllined') 8 | self.edit("CLUSTER-INITIAL", 'clusterinit') 9 | self.edit("CLUSTER-FINAL", 'clusterfina') 10 | self.scriptPrefix() 11 | self.lower() 12 | self.compress() 13 | 14 | 15 | if __name__ == "__main__": 16 | from glyphNameFormatter.exporters import printRange 17 | printRange("Zanabazar Square") 18 | -------------------------------------------------------------------------------- /changes_to_gnufl: -------------------------------------------------------------------------------- 1 | 00B9 onesuperior one.superior 2 | 00B2 twosuperior two.superior 3 | 00B3 threesuperior three.superior 4 | 5 | 0122 Gcedilla Gcommaaccent 6 | 0123 gcedilla gcommaaccent 7 | 0136 Kcedilla Kcommaaccent 8 | 0137 kcedilla kcommaaccent 9 | 013B Lcedilla Lcommaaccent 10 | 013C lcedilla lcommaaccent 11 | 0145 Ncedilla Ncommaaccent 12 | 0146 ncedilla ncommaaccent 13 | 0156 Rcedilla Rcommaaccent 14 | 0157 rcedilla rcommaaccent 15 | 1E10 Dcedilla Dcommaaccent 16 | 1E11 dcedilla dcommaaccent 17 | 18 | 27D1 dot andwithdot 19 | 21B1 arrowuprighttip arrowrightuptip 20 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/vedic_extensions.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("VEDIC") 5 | self.edit("SIGN", "sign") 6 | self.edit("TONE", "tone") 7 | self.edit("DOUBLE", "dbl") 8 | self.edit("TRIPLE", "tpl") 9 | self.edit("LONG", "long") 10 | self.edit("REVERSED", "reversed") 11 | 12 | self.processAs("Helper Indic") 13 | 14 | self.lower() 15 | self.compress() 16 | self.scriptPrefix() 17 | 18 | if __name__ == "__main__": 19 | from glyphNameFormatter.exporters import printRange 20 | printRange("Vedic Extensions") 21 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .venv 2 | .vscode 3 | 4 | *.pyc 5 | 6 | .idea/.name 7 | 8 | .DS_Store 9 | 10 | 11 | .idea/encodings.xml 12 | 13 | .idea/glyphNameFormatter.iml 14 | 15 | .idea/vcs.xml 16 | 17 | .idea/scopes/scope_settings.xml 18 | 19 | .idea/modules.xml 20 | 21 | .idea/misc.xml 22 | 23 | *.sublime-project 24 | 25 | *.sublime-workspace 26 | Lib/Glyph_Name_Formatter.egg-info 27 | ArabicShaping.txt 28 | CaseFolding.txt 29 | test_encodings 30 | .idea 31 | Lib/glyphNameFormatter/data/conflicts 32 | issues 33 | Lib/glyphNameFormatter/data/AGD.txt 34 | Lib/glyphNameFormatter/data/GlyphData.xml 35 | /issue\#87 36 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/cyrillic_supplement.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | # edits go here 4 | # self.edit("ARMENIAN") 5 | # self.handleCase() 6 | # self.compress() 7 | #self.edit("REVERSED") 8 | if self.has("REVERSED"): 9 | self.replace("REVERSED", "reversed") 10 | if self.has("MIDDLE"): 11 | self.replace("MIDDLE", "middle") 12 | self.edit("WITH") 13 | self.processAs("Cyrillic") 14 | self.compress() 15 | 16 | 17 | if __name__ == "__main__": 18 | from glyphNameFormatter.exporters import printRange 19 | printRange("Cyrillic Supplement") 20 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/telugu.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("TELUGU") 4 | self.edit("LETTER") 5 | self.edit("DIGIT") 6 | self.edit("CANDRABINDU", "candrabindu") 7 | self.processAs("Helper Indic") 8 | self.edit("ABOVE", "above") 9 | self.edit("VOWEL SIGN", "sign") 10 | self.edit("VOWEL") 11 | self.edit("SIGN", "sign") 12 | self.processAs("Helper Numbers") 13 | self.lower() 14 | self.compress() 15 | self.scriptPrefix() 16 | 17 | if __name__ == "__main__": 18 | from glyphNameFormatter.exporters import printRange 19 | printRange("Telugu") 20 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/enclosed_alphanumerics.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.processAs("Helper Digit Names") 4 | self.edit("DOUBLE CIRCLED", "circledbl") 5 | self.edit("CIRCLED", "circle") 6 | self.edit("DIGIT") 7 | self.edit("LATIN") 8 | self.edit("NUMBER") 9 | self.edit("PARENTHESIZED", "parenthesized") 10 | self.edit("FULL STOP", "period") 11 | self.edit("NEGATIVE", "black") 12 | self.handleCase() 13 | self.compress() 14 | 15 | if __name__ == "__main__": 16 | from glyphNameFormatter.exporters import printRange 17 | printRange("Enclosed Alphanumerics") 18 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/javanese.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | # edits go here 5 | self.edit("JAVANESE") 6 | self.edit("SIGN") 7 | self.edit("LETTER") 8 | 9 | parts = [ 10 | "VOWEL", "CONSONANT", 11 | "LEFT", "RIGHT", 12 | "PADA" 13 | ] 14 | for part in parts: 15 | self.edit(part, part.lower()) 16 | 17 | self.edit("DIGIT") 18 | self.processAs("Helper Digit Names") 19 | self.lower() 20 | self.compress() 21 | 22 | if __name__ == "__main__": 23 | from glyphNameFormatter.exporters import printRange 24 | printRange("Javanese") 25 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/vertical_forms.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("PRESENTATION FORM FOR") 4 | self.edit("LENTICULAR") 5 | self.edit("EXCLAMATION MARK", "exclam") 6 | self.edit("QUESTION MARK", "question") 7 | self.edit("VERTICAL") 8 | self.edit("HORIZONTAL", "hor") 9 | self.edit("WHITE", "white") 10 | self.edit("LEFT", "left") 11 | self.edit("RIGHT", "right") 12 | self.lower() 13 | self.compress() 14 | self.scriptPrefix() 15 | 16 | if __name__ == "__main__": 17 | from glyphNameFormatter.exporters import printRange 18 | printRange("Vertical Forms") 19 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/helper_indic.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("VOWEL SIGN", "sign") 4 | self.edit("SIGN NUKTA", "nukta") 5 | self.edit("SIGN VIRAMA", "virama") 6 | self.edit("SIGN AVAGRAHA", "avagraha") 7 | self.edit("SIGN VISARGA", "visarga") 8 | self.edit("SIGN ANUSVARA", "anusvara") 9 | self.edit("SIGN CANDRABINDU", "candrabindu") 10 | self.edit("CANDRA", "candra") 11 | 12 | self.edit("RUPEE MARK", "rupeemark") 13 | self.edit("RUPEE SIGN", "rupee") 14 | 15 | if __name__ == "__main__": 16 | from glyphNameFormatter.exporters import printRange 17 | printRange("Helper Indic") 18 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/mongolian.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | # edits go here 4 | self.edit("MONGOLIAN") 5 | self.edit("DIGIT") 6 | 7 | self.replace("FULL STOP", "period") 8 | 9 | parts = [ 10 | "TODO", "SIBE", "MANCHU", "ALI GALI", "HALF", "THREE", 11 | 12 | "INVERTED", 13 | ] 14 | for part in parts: 15 | self.edit(part, part.lower().replace(" ", "")) 16 | 17 | self.replace("LETTER") 18 | 19 | self.lower() 20 | self.compress() 21 | self.scriptPrefix() 22 | 23 | if __name__ == "__main__": 24 | from glyphNameFormatter.exporters import printRange 25 | printRange("Mongolian") 26 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/malayalam.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | # edits go here 5 | self.edit("MALAYALAM") 6 | 7 | self.edit("MARK") 8 | self.edit("VOWEL") 9 | 10 | self.edit("VOCALIC", "vocal") 11 | self.edit("SIGN", "sign") 12 | 13 | self.edit("CHILLU", "chillu") 14 | 15 | self.processAs("Helper Digit Names") 16 | 17 | self.edit("DIGIT") 18 | self.edit("NUMBER") 19 | self.edit("FRACTION") 20 | self.edit("LETTER") 21 | self.lower() 22 | self.compress() 23 | self.scriptPrefix() 24 | 25 | if __name__ == "__main__": 26 | from glyphNameFormatter.exporters import printRange 27 | printRange("Malayalam") 28 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/number_forms.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | 4 | # nmbr:oneeighth -> oneeighth 5 | # nmbr:onetenth -> onetenth 6 | # nmbr:onefifth -> onefifth 7 | self.replace("FRACTION NUMERATOR ONE", "onefraction") 8 | self.replace("LATIN SMALL LETTER REVERSED C", "creversed") 9 | 10 | self.replace("VULGAR FRACTION") 11 | 12 | self.editToFinal("SMALL ROMAN", ".romansmall") 13 | self.editToFinal("ROMAN", ".roman") 14 | 15 | self.replace("NUMERAL") 16 | 17 | self.lower() 18 | self.compress() 19 | 20 | if __name__ == "__main__": 21 | from glyphNameFormatter.exporters import printRange 22 | printRange("Number Forms") 23 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/superscripts_and_subscripts.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("PARENTHESIS", "paren") 4 | self.edit("EQUALS SIGN", "equal") 5 | self.edit("PLUS SIGN", "plus") 6 | self.edit("MINUS", "minus") 7 | 8 | self.edit("LEFT", "left") 9 | self.edit("RIGHT", "right") 10 | 11 | self.edit("SUPERSCRIPT", ".superior") 12 | self.edit("SUBSCRIPT", ".inferior") 13 | self.processAs("Helper Digit Names") 14 | self.edit("LATIN") 15 | self.handleCase() 16 | self.compress() 17 | 18 | if __name__ == "__main__": 19 | from glyphNameFormatter.exporters import printRange 20 | printRange("Superscripts and Subscripts") 21 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/hiragana.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("LETTER") 4 | self.edit("SMALL", "small") 5 | self.edit("KATAKANA-HIRAGANA VOICED SOUND MARK", "voicedmarkkana") 6 | self.edit("KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK", "semivoicedmarkkana") 7 | self.edit("HIRAGANA ITERATION MARK", "iterationhiragana") 8 | self.edit("HIRAGANA VOICED ITERATION MARK", "voicediterationhiragana") 9 | # self.editToFinal("HIRAGANA", "hiragana") 10 | self.editToFinal("HIRAGANA") 11 | self.editToFinal("COMBINING", "cmb") 12 | self.lower() 13 | self.scriptPrefix() 14 | 15 | if __name__ == "__main__": 16 | from glyphNameFormatter.exporters import printRange 17 | printRange("Hiragana") 18 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/test/testFindArabDiacritics.py: -------------------------------------------------------------------------------- 1 | #coding:utf8 2 | 3 | 4 | # 5 | # 6 | # make a list of arabic marks 7 | 8 | inevitableExceptions = [ 9 | 1552, 10 | 1553, 11 | 1554, 12 | 1555, 13 | 1758, 14 | 1772, 15 | ] 16 | 17 | biditypes = {} 18 | from glyphNameFormatter import GlyphName 19 | for uniNumber in range(1, 0xffff): 20 | g = GlyphName(uniNumber) 21 | if not g.bidiType in biditypes: 22 | biditypes[g.bidiType] = [] 23 | biditypes[g.bidiType].append(uniNumber) 24 | 25 | candidates = [] 26 | for u in biditypes["NSM"]: 27 | g = GlyphName(u) 28 | if g.uniRangeName.find("Arabic") != -1 and g.uniNumber not in inevitableExceptions: 29 | candidates.append(u) 30 | print(g.uniNumber, g.uniName) 31 | print(candidates) 32 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/combining_diacritical_marks_for_symbols.py: -------------------------------------------------------------------------------- 1 | # Combining Diacritical Marks for Symbols 2 | #combining_diacritical_marks_for_symbols 3 | 4 | # camelcase looks good for the longer names 5 | # but the range Combining Diacritical Marks Supplement 6 | # does everything lowercase. 7 | 8 | def process(self): 9 | 10 | self.edit("COMBINING") 11 | self.edit("OPEN") 12 | self.edit("ACCENT") 13 | self.edit("FLATTENED", "flat") 14 | 15 | self.processAs("Helper Diacritics") 16 | self.handleCase() 17 | 18 | self.camelCase() 19 | self.compress() 20 | self.scriptPrefix() 21 | 22 | 23 | if __name__ == "__main__": 24 | from glyphNameFormatter.exporters import printRange 25 | printRange("Combining Diacritical Marks for Symbols") 26 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/supplemental_arrows_b.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | # The names in this range are quite long, but not really 4 | # any redundancy in the words. It is all relevant and 5 | # even contractions from rightward to right already cause 6 | # duplicates. So, camelCase seems like a reasonable approach. 7 | # Names are still very long though. What is the preference? 8 | # arrowPointingRightwardsThenCurvingDownwards - 2967 ⥧ LEFTWARDS HARPOON WITH BARB DOWN ABOVE RIGHTWARDS HARPOON WITH BARB DOWN 9 | 10 | 11 | def process(self): 12 | self.edit("-", " ") 13 | self.camelCase() 14 | 15 | 16 | if __name__ == "__main__": 17 | from glyphNameFormatter.exporters import printRange 18 | printRange("Supplemental Arrows-B") 19 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/supplemental_arrows_c.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | # The names in this range are quite long, but not really 4 | # any redundancy in the words. It is all relevant and 5 | # even contractions from rightward to right already cause 6 | # duplicates. So, camelCase seems like a reasonable approach. 7 | # Names are still very long though. What is the preference? 8 | # arrowPointingRightwardsThenCurvingDownwards - 2967 ⥧ LEFTWARDS HARPOON WITH BARB DOWN ABOVE RIGHTWARDS HARPOON WITH BARB DOWN 9 | 10 | 11 | def process(self): 12 | self.edit("-", " ") 13 | self.camelCase() 14 | 15 | 16 | if __name__ == "__main__": 17 | from glyphNameFormatter.exporters import printRange 18 | printRange("Supplemental Arrows-C") 19 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/0FE10-0FE1F vertical_forms.txt: -------------------------------------------------------------------------------- 1 | # Vertical Forms 0FE10 - 0FE1F 2 | FE10 vert:comma PRESENTATION FORM FOR VERTICAL COMMA 3 | FE11 vert:ideographiccomma PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC COMMA 4 | FE12 vert:ideographicfullstop PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC FULL STOP 5 | FE13 vert:colon PRESENTATION FORM FOR VERTICAL COLON 6 | FE14 vert:semicolon PRESENTATION FORM FOR VERTICAL SEMICOLON 7 | FE15 vert:exclam PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK 8 | FE16 vert:question PRESENTATION FORM FOR VERTICAL QUESTION MARK 9 | FE17 vert:bracketwhiteleft PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET 10 | FE18 vert:brakcetwhiteright PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET 11 | FE19 vert:ellipsishor PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/gujarati.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | 4 | #GUJARATI VOWEL SIGN CANDRA E 5 | #GUJARATI VOWEL CANDRA E 6 | 7 | self.edit("GUJARATI") 8 | self.edit("LETTER") 9 | self.edit("DIGIT") 10 | self.processAs("Helper Indic") 11 | self.edit("VOWEL SIGN", "sign") 12 | self.edit("VOWEL") 13 | self.edit("SIGN") 14 | 15 | self.edit("THREE-DOT NUKTA ABOVE", "threedotnuktaabove") 16 | self.edit("TWO-CIRCLE NUKTA ABOVE", "twocirclenuktaabove") 17 | 18 | self.processAs("Helper Numbers") 19 | self.lower() 20 | self.compress() 21 | self.scriptPrefix() 22 | 23 | 24 | if __name__ == "__main__": 25 | from glyphNameFormatter.exporters import printRange 26 | from glyphNameFormatter.tools import debug 27 | printRange("Gujarati") 28 | debug(0x0AFA) -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/latin_extended_c.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | # edits go here 5 | self.edit("LATIN") 6 | 7 | self.forceScriptPrefix("latin", "CAPITAL LETTER ALPHA", "Alpha") 8 | self.forceScriptPrefix("latin", "CAPITAL LETTER TURNED ALPHA", "Alphaturned") 9 | 10 | self.replace("LETTER SMALL CAPITAL TURNED E", "Esmallturned") 11 | 12 | self.edit("DOUBLE", "dbl") 13 | self.edit("BAR", "bar") 14 | self.edit("SUBSCRIPT", ".inferior") 15 | self.edit("HALF", "half") 16 | self.edit("TAILLESS", "tailless") 17 | 18 | self.edit("DIAGONAL") 19 | self.edit("WITH") 20 | 21 | self.processAs("Helper Diacritics") 22 | self.processAs("Helper Shapes") 23 | self.handleCase() 24 | self.compress() 25 | 26 | if __name__ == "__main__": 27 | from glyphNameFormatter.exporters import printRange 28 | printRange("Latin Extended-C") 29 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/kannada.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("KANNADA") 4 | self.edit("LETTER") 5 | self.edit("DIGIT") 6 | self.edit("VOWEL SIGN VOCALIC", "vocalsign") 7 | self.edit("VOWEL SIGN", "sign") 8 | self.edit("VOCALIC", "vocal") 9 | 10 | self.edit("LENGTH MARK", "length") 11 | 12 | self.edit("SIGN NUKTA", "nukta") 13 | self.edit("SIGN VIRAMA", "virama") 14 | self.edit("SIGN AVAGRAHA", "avagraha") 15 | self.edit("SIGN VISARGA", "visarga") 16 | self.edit("SIGN ANUSVARA", "anusvara") 17 | self.edit("SIGN JIHVAMULIYA", "jihvamuliya") 18 | self.edit("SIGN UPADHMANIYA", "upadhmaniya") 19 | 20 | self.processAs("Helper Digit Names") 21 | self.lower() 22 | self.compress() 23 | self.scriptPrefix() 24 | 25 | 26 | if __name__ == "__main__": 27 | from glyphNameFormatter.exporters import printRange 28 | printRange("Kannada") 29 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/bengali.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("BENGALI") 4 | 5 | # parts 6 | self.edit("LETTER") 7 | self.edit("DIGIT") 8 | self.processAs("Helper Indic") 9 | self.edit("VOWEL SIGN", "sign") 10 | 11 | self.edit("NUMERATOR ONE LESS THAN THE DENOMINATOR", "oneless") 12 | self.edit("CURRENCY NUMERATOR", "currency", "numerator") 13 | self.edit("CURRENCY DENOMINATOR", "currency", "denominator") 14 | self.edit("RUPEE MARK", "rupeemark") 15 | self.edit("RUPEE SIGN", "rupee") 16 | 17 | self.edit("WITH MIDDLE DIAGONAL", "middiagonal") 18 | self.edit("WITH LOWER DIAGONAL", "lowdiagonal") 19 | 20 | self.processAs("Helper Numbers") 21 | 22 | self.lower() 23 | self.compress() 24 | self.scriptPrefix() 25 | 26 | 27 | if __name__ == "__main__": 28 | from glyphNameFormatter.exporters import printRange 29 | printRange("Bengali") 30 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/georgian.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | # edits go here 4 | self.edit("GEORGIAN PARAGRAPH SEPARATOR", "paragraphseparator") 5 | self.edit("MODIFIER LETTER GEORGIAN NAR", "narmodGeor") 6 | self.edit("GEORGIAN LETTER HARD SIGN", "hardsignGeor") 7 | self.edit("GEORGIAN LETTER LABIAL SIGN", "labialsignGeor") 8 | 9 | self.edit("GEORGIAN") 10 | self.handleCase() 11 | if self.has("GEORGIAN LETTER") and self.uniNumber not in [0x10FC, 0x10FE, 0x10FF]: 12 | self.edit("LETTER") 13 | self.suffix("Geor") #Mkhedruli 14 | self.lower() 15 | elif self.has("GEORGIAN CAPITAL LETTER"): 16 | self.suffix("Geok") #Asomtavruli 17 | self.compress() 18 | if self.has("GEORGIAN PARAGRAPH SEPARATOR"): 19 | self.scriptPrefix() 20 | 21 | 22 | if __name__ == "__main__": 23 | from glyphNameFormatter.exporters import printRange 24 | printRange("Georgian") 25 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/box_drawing.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("BOX DRAWINGS") 4 | self.replace("AND") 5 | self.replace("TO") 6 | self.replace("LIGHT", "light") 7 | self.replace("HEAVY", "heavy") 8 | self.replace("VERTICAL", "vert") 9 | self.replace("HORIZONTAL", "horz") 10 | self.replace("DIAGONAL", "diag") 11 | self.replace("SINGLE", "sng") 12 | self.replace("DOUBLE", "dbl") 13 | self.replace("TRIPLE", "trpl") 14 | self.replace("QUADRUPLE", "quad") 15 | self.replace("QUAD", "quad") 16 | self.replace("UPPER", "up") 17 | self.replace("DOWN", "dn") 18 | self.replace("LOWER", "dn") 19 | self.replace("DASH", "dash") 20 | self.replace("LEFT", "left") 21 | self.replace("RIGHT", "right") 22 | self.lower() 23 | self.compress() 24 | 25 | if __name__ == "__main__": 26 | from glyphNameFormatter.exporters import printRange 27 | printRange("Box Drawing") 28 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/combining_diacritical_marks_supplement.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("LATIN") 4 | 5 | self.edit("BREVE-MACRON", "brevemacron") 6 | self.edit("MACRON-BREVE", "macronbreve") 7 | self.edit("GRAVE-MACRON", "gravemacron") 8 | self.edit("MACRON-GRAVE", "macrongrave") 9 | self.edit("ACUTE-MACRON", "acutemacron") 10 | self.edit("MACRON-ACUTE", "macronacute") 11 | 12 | self.edit("GRAVE-ACUTE-GRAVE", "graveacutegrave") 13 | self.edit("ACUTE-GRAVE-ACUTE", "acutegraveacute") 14 | 15 | self.edit("COMBINING") 16 | self.edit("OPEN") 17 | self.edit("ACCENT") 18 | self.edit("FLATTENED", "flat") 19 | 20 | self.processAs("Helper Diacritics") 21 | self.handleCase() 22 | 23 | self.lower() 24 | self.compress() 25 | self.scriptPrefix() 26 | 27 | if __name__ == "__main__": 28 | from glyphNameFormatter.exporters import printRange 29 | printRange("Combining Diacritical Marks Supplement") 30 | -------------------------------------------------------------------------------- /banner.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | GLYPHNAME 7 | 8 | 9 | 10 | 11 | FORMATTER 12 | 13 | 14 | 15 | 16 | unicode16 17 | 18 | 19 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/latin_extended_additional.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("LATIN") 5 | # edits go here 6 | self.edit("CAPITAL LETTER D WITH CEDILLA", "Dcommaaccent") 7 | self.edit("SMALL LETTER D WITH CEDILLA", "dcommaaccent") 8 | self.replace("CAPITAL LETTER MIDDLE-WELSH LL", "LLwelsh") 9 | 10 | # self.edit("WITH DOT BELOW AND DOT ABOVE", "dotbelow", "dotaccent") 11 | # self.edit("WITH DOT BELOW", "dotbelow") 12 | # self.edit("WITH DOT ABOVE", "dotaccent") 13 | # self.edit("AND DOT ABOVE", "dotacent") 14 | self.edit("MIDDLE-WELSH", "welsh") 15 | 16 | self.replace("CAPITAL LETTER SHARP S", "Germandbls") 17 | 18 | self.forceScriptPrefix("latin", "SMALL LETTER DELTA", "delta") 19 | 20 | self.processAs("Helper Diacritics") 21 | self.handleCase() 22 | self.compress() 23 | 24 | if __name__ == "__main__": 25 | from glyphNameFormatter.exporters import printRange 26 | printRange("Latin Extended Additional") 27 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/miscellaneous_mathematical_symbols_a.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("MATHEMATICAL") 5 | self.replace("PARENTHESIS", "paren") 6 | self.edit("AND WITH DOT", "andwithdot") 7 | self.edit("FLATTENED", "flat") 8 | self.edit("CONCAVE-SIDED DIAMOND", "convavediamond") 9 | self.edit("LEFTWARDS", "left") 10 | self.edit("RIGHTWARDS", "right") 11 | self.edit("LEFT AND RIGHT", "leftright") 12 | self.edit("UPWARDS", "up") 13 | self.edit("UPPER", "up") 14 | self.edit("TORTOISE SHELL", "shell") 15 | self.edit("S-SHAPED", "sshape") 16 | parts = [ 17 | "WHITE", "ANGLE", "SQUARE", "DIAMOND", "FULL", 18 | "REVERSE", "SUPERSET", "PRECEDING", 19 | ] 20 | for part in parts: 21 | self.edit(part, part.lower()) 22 | 23 | self.edit("AND") 24 | self.processAs("Mathematical Operators") 25 | 26 | 27 | if __name__ == "__main__": 28 | from glyphNameFormatter.exporters import printRange 29 | printRange("Miscellaneous Mathematical Symbols-A") 30 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/alphabetic_presentation_forms.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.data.scriptPrefixes import scriptPrefixes 2 | 3 | 4 | def process(self): 5 | if self.has("LATIN"): 6 | self.scriptTag = scriptPrefixes['latin'] 7 | if self.has("ARMENIAN"): 8 | # self.scriptTag = scriptPrefixes['armenian'] 9 | self.processAs("Armenian") 10 | elif self.has("HEBREW"): 11 | # self.scriptTag = scriptPrefixes['hebrew'] 12 | self.processAs("Hebrew") 13 | 14 | self.edit("LATIN SMALL LIGATURE FFI", "f_f_i") 15 | self.edit("LATIN SMALL LIGATURE FFL", "f_f_l") 16 | self.edit("LATIN SMALL LIGATURE FF", "f_f") 17 | self.edit("LATIN SMALL LIGATURE FI", "fi") 18 | self.edit("LATIN SMALL LIGATURE FL", "fl") 19 | self.edit("LATIN SMALL LIGATURE LONG S T", "longs_t") 20 | self.edit("LATIN SMALL LIGATURE ST", "s_t") 21 | 22 | self.compress() 23 | 24 | if __name__ == "__main__": 25 | from glyphNameFormatter.exporters import printRange 26 | printRange("Alphabetic Presentation Forms") 27 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/020A0-020CF currency_symbols.txt: -------------------------------------------------------------------------------- 1 | # Currency Symbols 020A0 - 020CF 2 | 20A0 euroarchaic EURO-CURRENCY SIGN 3 | 20A1 colonmonetary COLON SIGN 4 | 20A2 cruzeiro CRUZEIRO SIGN 5 | 20A3 franc FRENCH FRANC SIGN 6 | 20A4 lira LIRA SIGN 7 | 20A5 mill MILL SIGN 8 | 20A6 naira NAIRA SIGN 9 | 20A7 peseta PESETA SIGN 10 | 20A8 rupee RUPEE SIGN 11 | 20A9 won WON SIGN 12 | 20AA newsheqel NEW SHEQEL SIGN 13 | 20AB dong DONG SIGN 14 | 20AC Euro EURO SIGN 15 | 20AD kip KIP SIGN 16 | 20AE tugrik TUGRIK SIGN 17 | 20AF drachma DRACHMA SIGN 18 | 20B0 germanpenny GERMAN PENNY SIGN 19 | 20B1 peso PESO SIGN 20 | 20B2 guarani GUARANI SIGN 21 | 20B3 austral AUSTRAL SIGN 22 | 20B4 hryvnia HRYVNIA SIGN 23 | 20B5 cedi CEDI SIGN 24 | 20B6 livretournois LIVRE TOURNOIS SIGN 25 | 20B7 spesmilo SPESMILO SIGN 26 | 20B8 tenge TENGE SIGN 27 | 20B9 indianrupee INDIAN RUPEE SIGN 28 | 20BA turkishlira TURKISH LIRA SIGN 29 | 20BB nordicmark NORDIC MARK SIGN 30 | 20BC manat MANAT SIGN 31 | 20BD ruble RUBLE SIGN 32 | 20BE lari LARI SIGN 33 | 20BF bitcoin BITCOIN SIGN 34 | 20C0 som SOM SIGN -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/cjk_compatibility_forms.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("PRESENTATION FORM FOR") 4 | self.edit("LOW LINE", "underscore") 5 | self.edit("LEFT PARENTHESIS", "parenleft") 6 | self.edit("RIGHT PARENTHESIS", "parenright") 7 | self.edit("LEFT CURLY BRACKET", "braceleft") 8 | self.edit("RIGHT CURLY BRACKET", "braceright") 9 | self.edit("DOUBLE WAVY", "dblwavy") 10 | self.replace("DOUBLE", "dbl") 11 | self.edit("WAVY", "wavy") 12 | self.edit("DASHED", "dashed") 13 | self.edit("CENTRELINE", "centerline") 14 | 15 | self.edit("LEFT", "left") 16 | self.edit("RIGHT", "right") 17 | 18 | self.edit("VERTICAL", "vertical") 19 | # self.edit("SQUARE", "fullwidth") 20 | # self.edit("IDEOGRAPHIC TELEGRAPH SYMBOL FOR", "telegraph") 21 | # self.edit("-") 22 | # self.processAs("Helper Digit Names") 23 | self.lower() 24 | self.compress() 25 | 26 | if __name__ == "__main__": 27 | from glyphNameFormatter.exporters import printRange 28 | printRange("CJK Compatibility Forms") 29 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/enclosed_alphanumeric_supplement.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("LATIN") 4 | self.edit("DIGIT") 5 | 6 | self.edit("TORTOISE SHELL BRACKETED", "shell") 7 | self.edit("PARENTHESIZED", "parens") 8 | self.edit("ITALIC", "italic") 9 | self.edit("CROSSED", "cross") 10 | self.edit("SQUARED", "square") 11 | self.edit("CIRCLED", "circle") 12 | self.edit("NEGATIVE", "black") 13 | 14 | shouldHandleCase = True 15 | keepCaps = [ 16 | "SA", "PA", "IC", "PPV", "SS", "SD", "MV", "HV", 17 | "WZ", "CD", 18 | ] 19 | for c in keepCaps: 20 | if self.has(" %s" % c): 21 | self.lower() 22 | self.replace(c.lower(), c) 23 | shouldHandleCase = False 24 | 25 | if shouldHandleCase: 26 | self.handleCase() 27 | if not self.has("CAPITAL"): 28 | self.lower() 29 | 30 | self.compress() 31 | 32 | if __name__ == "__main__": 33 | from glyphNameFormatter.exporters import printRange 34 | printRange("Enclosed Alphanumeric Supplement") 35 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | from setuptools import setup 4 | import re 5 | 6 | 7 | version = '' 8 | with open('Lib/glyphNameFormatter/__init__.py', 'r') as fd: 9 | version = re.search(r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', 10 | fd.read(), re.MULTILINE).group(1) 11 | 12 | 13 | setup(name = "Glyph Name Formatter", 14 | version = version, 15 | description = "Generate list of glyphnames from unicode names.", 16 | author = "Erik van Blokland, Frederik Berlaen", 17 | author_email = "erik@letterror.com, frederik@typemytype.com", 18 | url = "https://github.com/LettError/glyphNameFormatter", 19 | license = "BSD 3 Clause", 20 | packages = [ 21 | "glyphNameFormatter", 22 | "glyphNameFormatter.data", 23 | "glyphNameFormatter.rangeProcessors", 24 | "glyphNameFormatter.test", 25 | "glyphNameFormatter.exporters", 26 | ], 27 | package_dir = {"":"Lib"}, 28 | package_data = { 29 | 'glyphNameFormatter': ['data/*.txt', 'data/*.html', 'data/*.xml'], 30 | } 31 | ) 32 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/cjk_symbols_and_punctuation.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("HANGZHOU NUMERAL", "hangzhou") 4 | 5 | self.edit("JAPANESE INDUSTRIAL STANDARD SYMBOL", "jis") 6 | self.edit("CIRCLED POSTAL MARK", "circlepostalmark") 7 | self.edit("REVERSED DOUBLE PRIME QUOTATION MARK", "quotedblprimereversed") 8 | self.edit("DOUBLE PRIME QUOTATION MARK", "quotedblprime") 9 | self.edit("LEFT DOUBLE ANGLE BRACKET", "dblanglebracketleft") 10 | self.edit("RIGHT DOUBLE ANGLE BRACKET", "dblanglebracketright") 11 | self.edit("IDEOGRAPHIC NUMBER ZERO", "ideographiczero") 12 | self.edit("REVERSED", "reversed") 13 | self.edit("CLOSING MARK", "close") 14 | self.edit("FULL STOP", "period") 15 | self.edit("DOUBLE ANGLE", "dblangle") 16 | self.edit("DOUBLE", "dbl") 17 | self.edit("LEFT", "left") 18 | self.edit("RIGHT", "right") 19 | self.processAs("Helper Digit Names") 20 | self.lower() 21 | self.compress() 22 | 23 | if __name__ == "__main__": 24 | from glyphNameFormatter.exporters import printRange 25 | printRange("CJK Symbols and Punctuation") 26 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/halfwidth_and_fullwidth_forms.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.data.scriptPrefixes import scriptPrefixes 2 | 3 | 4 | def process(self): 5 | 6 | size = "NOSIZE" 7 | if self.has("FULLWIDTH"): 8 | size = "fullwidth" 9 | elif self.has("HALFWIDTH"): 10 | size = "halfwidth" 11 | self.replace("FULLWIDTH") 12 | self.replace("HALFWIDTH") 13 | if 0xFF01 <= self.uniNumber <= 0xFF5E: 14 | self.processAs('Basic Latin') 15 | self.edit("COMMERCIAL AT", "at") 16 | elif 0xFF65 <= self.uniNumber <= 0xFF9F: 17 | self.processAs('Katakana') 18 | self.forceScriptPrefix('katakana') 19 | elif 0xFFA0 <= self.uniNumber <= 0xFFDC: 20 | self.edit("HANGUL LETTER") 21 | self.processAs('Hangul') 22 | self.replace("-", '') 23 | self.lower() 24 | else: 25 | self.lower() 26 | self.scriptTag = scriptPrefixes[size] 27 | self.scriptPrefix() 28 | self.compress() 29 | 30 | 31 | if __name__ == "__main__": 32 | from glyphNameFormatter.exporters import printRange 33 | printRange("Halfwidth and Fullwidth Forms") 34 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/test/testMathGreeks.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | from glyphNameFormatter import GlyphName 4 | from glyphNameFormatter.unicodeRangeNames import * 5 | 6 | greekSymbols = [] 7 | pi = [] 8 | theta = [] 9 | for name in getAllRangeNames(): 10 | if name in ['Ancient Greek Musical Notation', 'Mathematical Alphanumeric Symbols']: continue 11 | a, b = getRangeByName(name) 12 | for uniNumber in range(a,b): 13 | g = GlyphName(uniNumber) 14 | if g.uniName is None: continue 15 | if "GREEK" in g.uniName and g.isMath: 16 | greekSymbols.append(g) 17 | 18 | if "GREEK" in g.uniName and ("LETTER PI" in g.uniName or "PI SYMBOL" in g.uniName): 19 | pi.append(g) 20 | 21 | if "GREEK" in g.uniName and ("LETTER THETA" in g.uniName or "THETA SYMBOL" in g.uniName): 22 | theta.append(g) 23 | 24 | 25 | print("\n\ngreek and math") 26 | for g in greekSymbols: 27 | print(g, g.uniRangeName, g.isMath) 28 | 29 | print("\n\ntheta") 30 | for g in theta: 31 | print(g, g.uniRangeName, g.isMath) 32 | 33 | print("\n\npi") 34 | for g in pi: 35 | print(g, g.uniRangeName, g.isMath) 36 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/letterlike_symbols.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("CONSTANT") 4 | self.replace("TO THE") 5 | self.replace("SIGN") 6 | self.replace("RECORDING") 7 | self.replace("TAKE") 8 | self.replace("SYMBOL") 9 | self.replace("SOURCE") 10 | self.replace("N-ARY") 11 | 12 | self.replace("SCRIPT SMALL L", "litre") 13 | self.replace("TURNED GREEK SMALL LETTER IOTA", "iotaturned") 14 | 15 | self.edit("DOUBLE-STRUCK", "dblstruck") 16 | self.edit("PRESCRIPTION", "prescription") 17 | self.edit("SCRIPT", "script") 18 | self.edit("BLACK-LETTER", "fraktur") 19 | self.edit("OVER TWO PI", "twopi") 20 | self.edit("INVERTED", "inverted") 21 | self.edit("TURNED", "turned") 22 | self.edit("ROTATED", "rotated") 23 | self.edit("REVERSED", "reversed") 24 | self.edit("SANS-SERIF", "sans") 25 | self.edit("ITALIC", "italic") 26 | 27 | self.compress() 28 | self.handleCase() 29 | if not self.has("CAPITAL"): 30 | self.lower() 31 | 32 | if __name__ == "__main__": 33 | from glyphNameFormatter.exporters import printRange 34 | printRange("Letterlike Symbols") 35 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/enclosed_cjk_letters_and_months.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | 4 | self.edit("IDEOGRAPHIC TELEGRAPH SYMBOL FOR", "telegraph") 5 | self.edit("PARENTHESIZED IDEOGRAPH", "ideographicparen") 6 | self.editToFinal("PARENTHESIZED", "paren") 7 | self.edit("CIRCLED IDEOGRAPH", "ideographiccircled") 8 | self.edit("CIRCLED NUMBER", "circle") 9 | self.replace("IDEOGRAPH", "ideographic") 10 | 11 | self.edit("KOREAN CHARACTER") 12 | self.edit("ON BLACK SQUARE", "square") 13 | self.edit("CIRCLED KATAKANA", "circlekatakana") 14 | self.edit("CIRCLED HANGUL", "circlekorean") # or hangul? 15 | 16 | self.edit("LIMITED LIABILITY SIGN", 'LTDfullwidth') 17 | self.edit("SQUARE HG", "Hgfullwidth") 18 | self.edit("SQUARE ERG", "ergfullwidth") 19 | self.edit("SQUARE EV", "eVfullwidth") 20 | self.edit("PARTNERSHIP SIGN", "partnership") 21 | 22 | self.edit("CIRCLED", "circle") 23 | 24 | self.processAs("Helper Digit Names") 25 | self.compress() 26 | self.lower() 27 | 28 | if __name__ == "__main__": 29 | from glyphNameFormatter.exporters import printRange 30 | printRange("Enclosed CJK Letters and Months") 31 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/arabic_presentation_forms_b.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | # If the Arabic ligature names comes with any of these terms then these rules apply on components: 4 | 5 | # Initial ligature: FIRST component is INIT and the REST are MEDI 6 | # Medial ligature: ALL the components are MEDI 7 | # Final ligature: the LAST component is FINA and the rest are MEDI 8 | # Isolate ligature: The LAST components is FINA, the fist components is INIT and the rest are MEDI 9 | 10 | 11 | #self.edit("ARABIC TATWEEL WITH FATHATAN ABOVE", "tatweelfathatanabove") 12 | #self.edit("ARABIC KASRATAN ISOLATED FORM", "kasratan") 13 | #self.edit("ARABIC FATHA MEDIAL FORM", "fathamedial") 14 | #self.edit("ARABIC LETTER ALEF WITH HAMZA ABOVE ISOLATED FORM", "alefhamzaabove.isol") 15 | 16 | if self.processAs("Helper Arabic Ligature Exceptions"): 17 | return 18 | 19 | if self.has("LIGATURE"): 20 | self.processAs("Helper Arabic Ligature") 21 | else: 22 | self.processAs("Arabic") 23 | 24 | 25 | if __name__ == "__main__": 26 | from glyphNameFormatter.exporters import printRange 27 | printRange("Arabic Presentation Forms-B") 28 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/helper_greek_diacritics.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.data.scriptPrefixes import scriptPrefixes 2 | 3 | def process(self): 4 | 5 | parts = { 6 | 'PROSGEGRAMMENI' : "iotasub", 7 | 'YPOGEGRAMMENI' : "iotasub", 8 | 'PERISPOMENI' : "tilde", 9 | 'VARIA' : "grave", 10 | 'PSILI' : "lenis", 11 | 'DIALYTIKA' : "dieresis", 12 | 'VRACHY' : "breve", 13 | 'OXIA' : "acute", 14 | 'DASIA' : "asper", 15 | "TONOS" : "tonos", 16 | } 17 | 18 | for prefix in ["WITH ", "AND ", ""]: 19 | for p in parts.keys(): 20 | self.replace(prefix+p, parts[p]) 21 | # output from Greek and Coptic will be lowercase 22 | for prefix in ["with ", "and ", ""]: 23 | for p in parts.keys(): 24 | self.replace((prefix+p).lower(), parts[p]) 25 | self.scriptTag = scriptPrefixes['greek'] 26 | 27 | 28 | if __name__ == "__main__": 29 | from glyphNameFormatter.exporters import printRange 30 | from glyphNameFormatter.tools import debug 31 | printRange("Greek Extended") 32 | debug(0x1FF2) 33 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/arabic_presentation_forms_a.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | # If the Arabic ligature names comes with any of these terms then these rules apply on components: 4 | 5 | # Initial ligature: FIRST component is INIT and the REST are MEDI 6 | # Medial ligature: ALL the components are MEDI 7 | # Final ligature: the LAST component is FINA and the rest are MEDI 8 | # Isolate ligature: The LAST components is FINA, the fist components is INIT and the rest are MEDI 9 | 10 | # and now we're using camelcase? 11 | 12 | # inevitableExceptions = { 13 | # # "ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM": "shaddadamatan", 14 | # } 15 | # for k, v in inevitableExceptions.items(): 16 | # if k == self.uniName: 17 | # self.edit(k, v) 18 | # return 19 | 20 | 21 | 22 | 23 | if self.processAs("Helper Arabic Ligature Exceptions"): 24 | return 25 | 26 | if self.has("LIGATURE"): 27 | self.processAs("Helper Arabic Ligature") 28 | else: 29 | self.processAs("Arabic") 30 | 31 | if __name__ == "__main__": 32 | from glyphNameFormatter.exporters import printRange 33 | printRange("Arabic Presentation Forms-A") 34 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/0FE50-0FE6F small_form_variants.txt: -------------------------------------------------------------------------------- 1 | # Small Form Variants 0FE50 - 0FE6F 2 | FE50 commasmall SMALL COMMA 3 | FE51 ideographiccommasmall SMALL IDEOGRAPHIC COMMA 4 | FE52 periodsmall SMALL FULL STOP 5 | FE54 semicolonsmall SMALL SEMICOLON 6 | FE55 colonsmall SMALL COLON 7 | FE56 questionsmall SMALL QUESTION MARK 8 | FE57 exclamsmall SMALL EXCLAMATION MARK 9 | FE58 emdashsmall SMALL EM DASH 10 | FE59 parenthesisleftsmall SMALL LEFT PARENTHESIS 11 | FE5A parenthesisrightsmall SMALL RIGHT PARENTHESIS 12 | FE5B braceleftsmall SMALL LEFT CURLY BRACKET 13 | FE5C bracerightsmall SMALL RIGHT CURLY BRACKET 14 | FE5D tortoiseshellbracketleftsmall SMALL LEFT TORTOISE SHELL BRACKET 15 | FE5E tortoiseshellbracketrightsmall SMALL RIGHT TORTOISE SHELL BRACKET 16 | FE5F numbersignsmall SMALL NUMBER SIGN 17 | FE60 ampersandsmall SMALL AMPERSAND 18 | FE61 asterisksmall SMALL ASTERISK 19 | FE62 plussmall SMALL PLUS SIGN 20 | FE63 hyphensmall SMALL HYPHEN-MINUS 21 | FE64 lesssmall SMALL LESS-THAN SIGN 22 | FE65 greatersmall SMALL GREATER-THAN SIGN 23 | FE66 equalsmall SMALL EQUALS SIGN 24 | FE68 backslashsmall SMALL REVERSE SOLIDUS 25 | FE69 dollarsmall SMALL DOLLAR SIGN 26 | FE6A percentsmall SMALL PERCENT SIGN 27 | FE6B commercialatsmall SMALL COMMERCIAL AT -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/general_punctuation.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.data.scriptPrefixes import scriptPrefixes 2 | 3 | 4 | def process(self): 5 | self.replace("VERTICAL LINE", "verticalbar") 6 | self.replace("QUESTION MARK", "question") 7 | self.replace("EXCLAMATION QUESTION", "exclam") 8 | self.replace("DOUBLE HIGH-REVERSED-9 QUOTATION MARK", "quotedblreversed") 9 | 10 | self.replace("TRIPLE PRIME", "millisecond") 11 | self.replace("DOUBLE PRIME", "second") 12 | self.replace("PRIME", "minute") 13 | 14 | self.replace("LEFT-TO-RIGHT", "lefttoright") 15 | self.replace("RIGHT-TO-LEFT", "righttoleft") 16 | 17 | self.edit("DOUBLE", "dbl") 18 | self.edit("REVERSED", "reversed") 19 | 20 | self.edit("LEFT", "left") 21 | self.edit("RIGHT", "right") 22 | self.edit("SQUARE", "square") 23 | self.edit("WITH QUILL", "quill") 24 | self.edit("EMBEDDING", "embed") 25 | 26 | self.replace("-") 27 | self.compress() 28 | self.lower() 29 | 30 | if not self.has("HYPHEN"): 31 | # solve conflict with HYPHEN-MINUS 002D 32 | self.scriptTag = scriptPrefixes["latin"] 33 | 34 | if __name__ == "__main__": 35 | from glyphNameFormatter.exporters import printRange 36 | printRange("General Punctuation") 37 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/01380-0139F ethiopic_supplement.txt: -------------------------------------------------------------------------------- 1 | # Ethiopic Supplement 01380 - 0139F 2 | 1380 ethi:mwasebatbeit ETHIOPIC SYLLABLE SEBATBEIT MWA 3 | 1381 ethi:mwi ETHIOPIC SYLLABLE MWI 4 | 1382 ethi:mwee ETHIOPIC SYLLABLE MWEE 5 | 1383 ethi:mwe ETHIOPIC SYLLABLE MWE 6 | 1384 ethi:bwasebatbeit ETHIOPIC SYLLABLE SEBATBEIT BWA 7 | 1385 ethi:bwi ETHIOPIC SYLLABLE BWI 8 | 1386 ethi:bwee ETHIOPIC SYLLABLE BWEE 9 | 1387 ethi:bwe ETHIOPIC SYLLABLE BWE 10 | 1388 ethi:fwasebatbeit ETHIOPIC SYLLABLE SEBATBEIT FWA 11 | 1389 ethi:fwi ETHIOPIC SYLLABLE FWI 12 | 138A ethi:fwee ETHIOPIC SYLLABLE FWEE 13 | 138B ethi:fwe ETHIOPIC SYLLABLE FWE 14 | 138C ethi:pwasebatbeit ETHIOPIC SYLLABLE SEBATBEIT PWA 15 | 138D ethi:pwi ETHIOPIC SYLLABLE PWI 16 | 138E ethi:pwee ETHIOPIC SYLLABLE PWEE 17 | 138F ethi:pwe ETHIOPIC SYLLABLE PWE 18 | 1390 ethi:yizet ETHIOPIC TONAL MARK YIZET 19 | 1391 ethi:deret ETHIOPIC TONAL MARK DERET 20 | 1392 ethi:rikrik ETHIOPIC TONAL MARK RIKRIK 21 | 1393 ethi:shortrikrik ETHIOPIC TONAL MARK SHORT RIKRIK 22 | 1394 ethi:difat ETHIOPIC TONAL MARK DIFAT 23 | 1395 ethi:kenat ETHIOPIC TONAL MARK KENAT 24 | 1396 ethi:chiret ETHIOPIC TONAL MARK CHIRET 25 | 1397 ethi:hidet ETHIOPIC TONAL MARK HIDET 26 | 1398 ethi:derethidet ETHIOPIC TONAL MARK DERET-HIDET 27 | 1399 ethi:kurt ETHIOPIC TONAL MARK KURT -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/mathematical_alphanumeric_symbols.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("MATHEMATICAL") 4 | 5 | self.edit("EPSILON SYMBOL", "epsilonsymbol") 6 | self.edit("CAPITAL THETA SYMBOL", "Thetasymbol") 7 | self.edit("THETA SYMBOL", "thetasymbol") 8 | self.edit("KAPPA SYMBOL", "kappasymbol") 9 | self.edit("PHI SYMBOL", "phisymbol") 10 | self.edit("PI SYMBOL", "pisymbol") 11 | self.edit("RHO SYMBOL", "rhosymbol") 12 | 13 | self.edit("MONOSPACE", "mono") 14 | self.edit("BOLD ITALIC", "bolditalic") 15 | self.edit("ITALIC", "italic") 16 | self.edit("BOLD", "bold") 17 | self.edit("SANS-SERIF", "sans") 18 | self.edit("FRAKTUR", "fraktur") 19 | self.edit("BLACK-LETTER", "fraktur") 20 | self.edit("PARTIAL DIFFERENTIAL", "partialdiff") 21 | self.edit("DOUBLE-STRUCK", "dblstruck") 22 | self.edit("SCRIPT", "script") 23 | self.edit("NABLA", "nabla") 24 | 25 | self.handleCase() 26 | 27 | 28 | 29 | if self.has("DIGIT"): 30 | self.edit("DIGIT") 31 | self.lower() 32 | 33 | self.compress() 34 | #self.scriptPrefix() 35 | 36 | 37 | if __name__ == "__main__": 38 | from glyphNameFormatter.exporters import printRange 39 | printRange("Mathematical Alphanumeric Symbols") 40 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/latin_extended_e.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.data.scriptPrefixes import scriptPrefixes 2 | 3 | 4 | def process(self): 5 | 6 | self.edit("MODIFIER LETTER LEFT TACK", "modLetterLeftTack") 7 | self.edit("MODIFIER LETTER RIGHT TACK", "modLetterRightTack") 8 | 9 | self.edit("LENIS", "lenis") 10 | self.edit("WITH CROSSED-TAIL", "tail") 11 | self.edit("SCRIPT", "script") 12 | self.edit("BLACKLETTER", "fractur") 13 | self.edit("REVERSED-SCHWA", "reversedschwa") 14 | self.edit("WITH INVERTED LAZY S", "lazyinverteds") 15 | self.edit("OPEN-O", "oopen") 16 | if self.has("LATIN SMALL LETTER CHI"): 17 | self.edit("LATIN SMALL LETTER CHI", 'chi') 18 | self.edit("WITH LOW RIGHT RING", 'lowrightring') 19 | self.edit("WITH LOW LEFT SERIF", 'lowleftserif') 20 | self.scriptTag = scriptPrefixes['latingreek'] 21 | 22 | 23 | self.processAs("Latin Extended-C") 24 | 25 | self.edit("MODIFIER", "mod") 26 | 27 | if self.has("GREEK"): 28 | self.edit("GREEK") 29 | 30 | self.processAs("Helper Latin Greeks") 31 | 32 | 33 | self.edit("-") 34 | 35 | self.compress() 36 | 37 | 38 | if __name__ == "__main__": 39 | from glyphNameFormatter.exporters import printRange 40 | printRange("Latin Extended-E") 41 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/tibetan.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("TIBETAN") 4 | if self.has("DIGIT"): 5 | self.edit("DIGIT") 6 | self.lower() 7 | 8 | self.edit("RIGHT-FACING SVASTI SIGN WITH DOTS", "svastirightdot") 9 | self.edit("LEFT-FACING SVASTI SIGN WITH DOTS", "svastileftdot") 10 | self.edit("RIGHT-FACING SVASTI SIGN", "svastiright") 11 | self.edit("LEFT-FACING SVASTI SIGN", "svastileft") 12 | 13 | self.edit("VOCALIC", "vocalic") 14 | self.edit("SYLLABLE", "syllable") 15 | self.edit("VOWEL", "vowel") 16 | self.edit("LOGOTYPE", "logotype") 17 | self.edit("INITIAL", 'initial') 18 | self.edit("CANTILLATION", "cantillation") 19 | self.edit("CLOSING", "closing") 20 | self.edit("SYMBOL", "symbol") 21 | self.edit("SUBJOINED", "subjoined") 22 | self.edit("FIXED-FORM", "fixed") 23 | self.edit("SIGN", 'sign') 24 | self.edit("MARK", 'mark') 25 | self.edit("LEFT", "left") 26 | self.edit("RIGHT", "right") 27 | 28 | self.edit("-A", "AA") # Old name TIBETAN LETTER AA 29 | self.edit("-") 30 | self.edit("LETTER") 31 | 32 | self.lower() 33 | self.compress() 34 | self.scriptPrefix() 35 | 36 | if __name__ == "__main__": 37 | from glyphNameFormatter.exporters import printRange 38 | printRange("Tibetan") 39 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/exporters/exportRangeOverviews.py: -------------------------------------------------------------------------------- 1 | from __future__ import print_function 2 | import glyphNameFormatter 3 | from glyphNameFormatter.unicodeRangeNames import getRangeByName, getAllRangeNames, getSupportedRangeNames 4 | import os 5 | 6 | skipped = {} 7 | 8 | def generateRange(rangeName): 9 | # generate all the names in the range 10 | lines = [] 11 | r = getRangeByName(rangeName) 12 | if r is None: 13 | print("unknown range name", rangeName) 14 | return 15 | start, end = r 16 | lines.append("# %s %05X - %05X" % (rangeName, start, end)) 17 | hasSupport = False 18 | for uniNumber in range(start, end+1): 19 | glyphName = glyphNameFormatter.GlyphName(uniNumber) 20 | if glyphName.hasName(): 21 | lines.append("%04X\t%s\t%s" % (uniNumber, glyphName.getName(extension=True), glyphName.uniName)) 22 | dirForNames = "../names/ranges/" 23 | if not os.path.exists(dirForNames): 24 | os.makedirs(dirForNames) 25 | rangeForFileName = "%05X-%05X %s" % (start, end, rangeName.replace(" ", "_").lower()) 26 | path = "../names/ranges/%s.txt" % rangeForFileName 27 | f = open(path, 'w') 28 | f.write("\n".join(lines)) 29 | f.close() 30 | 31 | if __name__ == "__main__": 32 | for rangeName in getSupportedRangeNames(): 33 | generateRange(rangeName) 34 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/geometric_shapes.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | 4 | self.replace("SQUARE WITH UPPER LEFT TO LOWER RIGHT FILL", "squareupperlefttolowerrightfill") 5 | self.replace("SQUARE WITH UPPER RIGHT TO LOWER LEFT FILL", "squareupperrighttolowerleftfill") 6 | 7 | ignores = [ 8 | "WITH" 9 | ] 10 | for ignore in ignores: 11 | self.replace(ignore) 12 | 13 | self.replace("ROUNDED CORNERS", "round") 14 | self.replace("CONTAINING", "with") 15 | 16 | self.replace("WHITE SQUARE", "squarewhite") 17 | self.replace("BLACK SQUARE", "squareblack") 18 | self.replace("WHITE DIAMOND", "diamondwhite") 19 | self.replace("BLACK DIAMOND", "diamondblack") 20 | 21 | self.edit("UP-POINTING", "up") 22 | self.edit("RIGHT-POINTING", "right") 23 | self.edit("LEFT-POINTING", "left") 24 | self.edit("DOWN-POINTING", "down") 25 | 26 | parts = [ 27 | "INVERSE", 28 | "VERTICAL", "HORIZONTAL", 29 | "SMALL", "FILL", 30 | "DOTTED", "MEDIUM", "LEFT", "RIGHT", "BLACK", "WHITE" 31 | ] 32 | for part in parts: 33 | self.edit(part, part.lower()) 34 | 35 | self.compress() 36 | self.lower() 37 | 38 | if __name__ == "__main__": 39 | from glyphNameFormatter.exporters import printRange 40 | printRange("Geometric Shapes") 41 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/armenian.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("ARMENIAN") 4 | 5 | self.edit("APOSTROPHE", "apostrophe") 6 | self.edit("EMPHASIS MARK", "emphasismark") 7 | self.edit("QUESTION MARK", "question") 8 | self.edit("EXCLAMATION MARK", "exclam") 9 | self.edit("ABBREVIATION MARK", 'abbreviationmark') 10 | self.edit("MODIFIER LETTER LEFT HALF RING", "ringhalfleft") 11 | self.edit("SMALL LIGATURE ECH YIWN", "ech_yiwn") 12 | 13 | # used in alphabetic presentation forms 14 | self.edit("SMALL LIGATURE MEN NOW", "men_now") 15 | self.edit("SMALL LIGATURE MEN ECH", "men_ech") 16 | self.edit("SMALL LIGATURE MEN INI", "men_ini") 17 | self.edit("SMALL LIGATURE VEW NOW", "vew_now") 18 | self.edit("SMALL LIGATURE MEN XEH", "men_xeh") 19 | 20 | self.edit("RIGHT-FACING", "rightfacing") 21 | self.edit("LEFT-FACING", "leftfacing") 22 | self.edit("ETERNITY SIGN", "eternitysign") 23 | self.edit("DRAM SIGN", "dramsign") 24 | self.edit("ARMENIAN") 25 | 26 | self.edit("COMMA", "comma") 27 | self.edit("FULL STOP", "period") 28 | self.edit("HYPHEN", "hyphen") 29 | self.handleCase() 30 | self.compress() 31 | self.scriptPrefix() 32 | 33 | if __name__ == "__main__": 34 | from glyphNameFormatter.exporters import printRange 35 | printRange("Armenian") 36 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/data/scriptConflictNames.py: -------------------------------------------------------------------------------- 1 | # Table with conflicting names. Generated by /exporters/analyseConflicts.py 2 | 3 | scriptConflictNames = [ 4 | "Beta", 5 | "Chi", 6 | "Ereversed", 7 | "I", 8 | "Ismall", 9 | "Lambda", 10 | "Omega", 11 | "a", 12 | "acute", 13 | "ae", 14 | "alpha", 15 | "baby", 16 | "beta", 17 | "bowtie", 18 | "chair", 19 | "chi", 20 | "cjkcompatibilityideograph#", 21 | "cjkunifiedideograph#", 22 | "comma", 23 | "cuberoot", 24 | "dash", 25 | "decimalseparator", 26 | "diamondblack", 27 | "diamondwhite", 28 | "e", 29 | "eight", 30 | "ereversed", 31 | "five", 32 | "four", 33 | "fourthroot", 34 | "gamma", 35 | "glottalstop", 36 | "grave", 37 | "gscript", 38 | "hook", 39 | "hyphen", 40 | "i", 41 | "iota", 42 | "khitansmallscriptcharacter#", 43 | "lambda", 44 | "marchenlettera", 45 | "nine", 46 | "numbersign", 47 | "nushucharacter#", 48 | "o", 49 | "oe", 50 | "omega", 51 | "one", 52 | "percent", 53 | "perthousand", 54 | "phi", 55 | "question", 56 | "rscript", 57 | "rtail", 58 | "semicolon", 59 | "seven", 60 | "six", 61 | "tangutideograph#", 62 | "three", 63 | "tilde", 64 | "two", 65 | "u", 66 | "upsilon", 67 | "zero", 68 | ] 69 | 70 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/arabic_supplement.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.tools import camelCase 2 | 3 | 4 | def process(self): 5 | # If the Arabic ligature names comes with any of these terms then these rules apply on components: 6 | 7 | # Initial ligature: FIRST component is INIT and the REST are MEDI 8 | # Medial ligature: ALL the components are MEDI 9 | # Final ligature: the LAST component is FINA and the rest are MEDI 10 | # Isolate ligature: The LAST components is FINA, the fist components is INIT and the rest are MEDI 11 | if "WITH" in self.uniName: 12 | parts = self.uniName.split(" ") 13 | withIndex = parts.index("WITH") 14 | withParts = parts[withIndex+1:] 15 | nameParts = parts[:withIndex] 16 | if nameParts[0] == 'ARABIC': 17 | nameParts = nameParts[1:] 18 | if nameParts[0] == 'LETTER': 19 | nameParts = nameParts[1:] 20 | self.replace("UPWARDS", "UP") 21 | self.replace("DOWNWARDS", "DOWN") 22 | self.replace("POINTING", "") 23 | self.replace("AND", "") 24 | self.edit("WITH") 25 | self.edit("EXTENDED ARABIC-INDIC") 26 | self.edit("ARABIC LETTER") 27 | self.camelCase() 28 | self.compress() 29 | 30 | 31 | if __name__ == "__main__": 32 | from glyphNameFormatter.exporters import printRange 33 | printRange("Arabic Supplement") 34 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/miscellaneous_symbols.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("BALLOT BOX", "checkbox") 4 | self.replace("WITH CHECK", "checked") 5 | self.replace("WITH X", "x") 6 | self.replace("SUIT") 7 | self.replace("CHESS") 8 | self.replace("SIGN") 9 | self.replace("RECYCLING", "recycle") 10 | self.replace("SYMBOL") 11 | self.replace("FOR GENERIC MATERIALS", "generic") 12 | self.replace("PARTIALLY-RECYCLED", "recyclepartially") 13 | self.replace("FOR TYPE-") 14 | self.replace("FACE-") 15 | self.replace("WITH") 16 | self.replace("FOR") 17 | self.replace("AND") 18 | 19 | self.processAs("helper_numbers") 20 | 21 | self.replace("WHITE DOT RIGHT", "whitedotright") 22 | self.replace("DOT RIGHT", "dotright") 23 | 24 | self.replace("WAY LEFT WAY", "wayleftway") 25 | self.edit("DOUBLE", "dbl") 26 | 27 | parts = [ 28 | "ASCENDING", "DESCENDING", 29 | "LEFT", "RIGHT", "UP", "DOWN", 30 | "REVERSED", "ROTATED", "OUTLINED", "HEAVY", 31 | "UNIVERSAL", 32 | "BLACK", "WHITE", 33 | ] 34 | for part in parts: 35 | self.edit(part, part.lower()) 36 | 37 | self.replace("-") 38 | self.lower() 39 | self.compress() 40 | 41 | 42 | if __name__ == "__main__": 43 | from glyphNameFormatter.exporters import printRange 44 | printRange("Miscellaneous Symbols") 45 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/helper_shapes.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("LITTLE", "little") 5 | self.edit("BIG", "big") 6 | self.edit("ROUND", "round") 7 | 8 | self.edit("SHORT", "short") 9 | self.edit("STRAIGHT", "straight") 10 | self.edit("BARRED", "barred") 11 | self.edit('OPEN', "open") 12 | self.edit('CLOSED', "closed") 13 | self.edit('REVERSED', "reversed") 14 | self.edit("MONOCULAR", "monocular") 15 | self.edit("SIDEWAYS", 'sideways') 16 | self.edit("BOTTOM HALF", 'bottomhalf') 17 | self.edit("TOP HALF", 'tophalf') 18 | 19 | self.edit("WITH TITLO", "titlo") 20 | self.edit("TITLO", "titlo") 21 | self.edit("WITH TAIL", "tail") 22 | self.edit("WITH TICK", "tick") 23 | self.edit("WITH DESCENDER", "descender") 24 | self.edit("WITH UPTURN", "up") 25 | self.edit("WITH STROKE", "stroke") 26 | self.edit("WITH VERTICAL STROKE", "verticalstroke") 27 | self.edit("WITH DIAGONAL STROKE", "diagonalstroke") 28 | self.edit("WITH HIGH STROKE", "highstroke") 29 | self.edit("WITH SWASH TAIL", "swash", "tail") 30 | self.edit("WITH COMMA BELOW", "commaaccent") 31 | self.edit("WITH PALATAL HOOK", "palatalhook") 32 | 33 | self.edit("REVERSED", "turned") 34 | self.edit("TURNED", "turned") 35 | self.edit("INVERTED", "inverted") 36 | self.edit("CENTRED", "centred") 37 | 38 | self.edit("LOOP", "loop") 39 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/devanagari.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("DEVANAGARI") 4 | 5 | # parts 6 | self.edit("LETTER") 7 | self.edit("DIGIT") 8 | self.edit("VOWEL SIGN", "sign") 9 | 10 | self.edit("SIGN CANDRABINDU", "candrabindu") 11 | self.edit("SIGN INVERTED CANDRABINDU", "candrabinduinverted") 12 | 13 | self.edit("CANDRA", "candra") 14 | self.edit("DOUBLE", "dbl") 15 | self.edit("SHORT", "short") 16 | self.edit("LONG", "long") 17 | 18 | 19 | self.processAs("Helper Indic") 20 | 21 | self.edit("DANDA", "danda") 22 | self.edit("GRAVE ACCENT", "grave") 23 | self.edit("ACUTE ACCENT", "acute") 24 | 25 | self.edit("STRESS SIGN") 26 | self.edit("PRISHTHAMATRA", "prishthamatra") 27 | self.edit("ABBREVIATION SIGN", "abbreviation") 28 | self.edit("SIGN HIGH SPACING DOT", "dothigh") 29 | self.edit("HEAVY", "heavy") 30 | self.edit("GLOTTAL STOP", "glottalstop") 31 | 32 | self.processAs("Helper Digit Names") 33 | 34 | # AGD uses camelcase, but there do not seem to be casing differences between the letters 35 | self.lower() 36 | self.compress() 37 | self.scriptPrefix() 38 | 39 | if __name__ == "__main__": 40 | from glyphNameFormatter.exporters import printRange 41 | printRange("Devanagari") 42 | from glyphNameFormatter.tools import debug 43 | debug(0x0955) 44 | debug(0x0900) 45 | debug(0x0901) -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/0AB00-0AB2F ethiopic_extended-a.txt: -------------------------------------------------------------------------------- 1 | # Ethiopic Extended-A 0AB00 - 0AB2F 2 | AB01 ethi:tthu ETHIOPIC SYLLABLE TTHU 3 | AB02 ethi:tthi ETHIOPIC SYLLABLE TTHI 4 | AB03 ethi:tthaa ETHIOPIC SYLLABLE TTHAA 5 | AB04 ethi:tthee ETHIOPIC SYLLABLE TTHEE 6 | AB05 ethi:tthe ETHIOPIC SYLLABLE TTHE 7 | AB06 ethi:ttho ETHIOPIC SYLLABLE TTHO 8 | AB09 ethi:ddhu ETHIOPIC SYLLABLE DDHU 9 | AB0A ethi:ddhi ETHIOPIC SYLLABLE DDHI 10 | AB0B ethi:ddhaa ETHIOPIC SYLLABLE DDHAA 11 | AB0C ethi:ddhee ETHIOPIC SYLLABLE DDHEE 12 | AB0D ethi:ddhe ETHIOPIC SYLLABLE DDHE 13 | AB0E ethi:ddho ETHIOPIC SYLLABLE DDHO 14 | AB11 ethi:dzu ETHIOPIC SYLLABLE DZU 15 | AB12 ethi:dzi ETHIOPIC SYLLABLE DZI 16 | AB13 ethi:dzaa ETHIOPIC SYLLABLE DZAA 17 | AB14 ethi:dzee ETHIOPIC SYLLABLE DZEE 18 | AB15 ethi:dze ETHIOPIC SYLLABLE DZE 19 | AB16 ethi:dzo ETHIOPIC SYLLABLE DZO 20 | AB20 ethi:cchha ETHIOPIC SYLLABLE CCHHA 21 | AB21 ethi:cchhu ETHIOPIC SYLLABLE CCHHU 22 | AB22 ethi:cchhi ETHIOPIC SYLLABLE CCHHI 23 | AB23 ethi:cchhaa ETHIOPIC SYLLABLE CCHHAA 24 | AB24 ethi:cchhee ETHIOPIC SYLLABLE CCHHEE 25 | AB25 ethi:cchhe ETHIOPIC SYLLABLE CCHHE 26 | AB26 ethi:cchho ETHIOPIC SYLLABLE CCHHO 27 | AB28 ethi:bba ETHIOPIC SYLLABLE BBA 28 | AB29 ethi:bbu ETHIOPIC SYLLABLE BBU 29 | AB2A ethi:bbi ETHIOPIC SYLLABLE BBI 30 | AB2B ethi:bbaa ETHIOPIC SYLLABLE BBAA 31 | AB2C ethi:bbee ETHIOPIC SYLLABLE BBEE 32 | AB2D ethi:bbe ETHIOPIC SYLLABLE BBE 33 | AB2E ethi:bbo ETHIOPIC SYLLABLE BBO -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/chess_symbols.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("CHESS", "") 4 | 5 | knightPieces = { 6 | 0xFA4E: 'white Knight Queen' , # 🩎 WHITE CHESS KNIGHT-QUEEN 7 | 0x1FA4F: 'white Knight Rook' , # 🩏 WHITE CHESS KNIGHT-ROOK 8 | 0x1FA50: 'white Knight Bishop' , # 🩐 WHITE CHESS KNIGHT-BISHOP 9 | 0x1FA51: 'black Knight Queen' , # 🩑 BLACK CHESS KNIGHT-QUEEN 10 | 0x1FA52: 'black Knight Rook' , # 🩒 BLACK CHESS KNIGHT-ROOK 11 | 0x1FA53: 'black Knight Bishop' , # 🩓 BLACK CHESS KNIGHT-BISHOP self.edit("ROTATED FORTY-FIVE DEGREES", "45") 12 | } 13 | if self.uniNumber in knightPieces: 14 | self.uniNameProcessed = knightPieces[self.uniNumber] 15 | 16 | 17 | self.edit("ROTATED FORTY-FIVE DEGREES", "45") 18 | self.edit("ROTATED NINETY DEGREES", "90") 19 | self.edit("ROTATED ONE HUNDRED THIRTY-FIVE DEGREES", "135") 20 | self.edit("ROTATED TWO HUNDRED TWENTY-FIVE DEGREES", "225") 21 | self.edit("ROTATED TWO HUNDRED SEVENTY DEGREES", "270") 22 | self.edit("ROTATED THREE HUNDRED FIFTEEN DEGREES", "315") 23 | self.edit("TURNED", "Turned") 24 | self.edit("XIANGQI", "Xq") 25 | self.camelCase() 26 | #self.edit("TAMIL") 27 | #self.edit("LETTER") 28 | pass 29 | 30 | 31 | if __name__ == "__main__": 32 | from glyphNameFormatter.exporters import printRange 33 | printRange("Chess Symbols") 34 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/1E7E0-1E7FF ethiopic_extended-b.txt: -------------------------------------------------------------------------------- 1 | # Ethiopic Extended-B 1E7E0 - 1E7FF 2 | 1E7E0 ethi:hhya ETHIOPIC SYLLABLE HHYA 3 | 1E7E1 ethi:hhyu ETHIOPIC SYLLABLE HHYU 4 | 1E7E2 ethi:hhyi ETHIOPIC SYLLABLE HHYI 5 | 1E7E3 ethi:hhyaa ETHIOPIC SYLLABLE HHYAA 6 | 1E7E4 ethi:hhyee ETHIOPIC SYLLABLE HHYEE 7 | 1E7E5 ethi:hhye ETHIOPIC SYLLABLE HHYE 8 | 1E7E6 ethi:hhyo ETHIOPIC SYLLABLE HHYO 9 | 1E7E8 ethi:hhwagurage ETHIOPIC SYLLABLE GURAGE HHWA 10 | 1E7E9 ethi:hhwi ETHIOPIC SYLLABLE HHWI 11 | 1E7EA ethi:hhwee ETHIOPIC SYLLABLE HHWEE 12 | 1E7EB ethi:hhwe ETHIOPIC SYLLABLE HHWE 13 | 1E7ED ethi:mwigurage ETHIOPIC SYLLABLE GURAGE MWI 14 | 1E7EE ethi:mweegurage ETHIOPIC SYLLABLE GURAGE MWEE 15 | 1E7F0 ethi:qwigurage ETHIOPIC SYLLABLE GURAGE QWI 16 | 1E7F1 ethi:qweegurage ETHIOPIC SYLLABLE GURAGE QWEE 17 | 1E7F2 ethi:qwegurage ETHIOPIC SYLLABLE GURAGE QWE 18 | 1E7F3 ethi:bwigurage ETHIOPIC SYLLABLE GURAGE BWI 19 | 1E7F4 ethi:bweegurage ETHIOPIC SYLLABLE GURAGE BWEE 20 | 1E7F5 ethi:kwigurage ETHIOPIC SYLLABLE GURAGE KWI 21 | 1E7F6 ethi:kweegurage ETHIOPIC SYLLABLE GURAGE KWEE 22 | 1E7F7 ethi:kwegurage ETHIOPIC SYLLABLE GURAGE KWE 23 | 1E7F8 ethi:gwigurage ETHIOPIC SYLLABLE GURAGE GWI 24 | 1E7F9 ethi:gweegurage ETHIOPIC SYLLABLE GURAGE GWEE 25 | 1E7FA ethi:gwegurage ETHIOPIC SYLLABLE GURAGE GWE 26 | 1E7FB ethi:fwigurage ETHIOPIC SYLLABLE GURAGE FWI 27 | 1E7FC ethi:fweegurage ETHIOPIC SYLLABLE GURAGE FWEE 28 | 1E7FD ethi:pwigurage ETHIOPIC SYLLABLE GURAGE PWI 29 | 1E7FE ethi:pweegurage ETHIOPIC SYLLABLE GURAGE PWEE -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/exporters/exportGlyphData.py: -------------------------------------------------------------------------------- 1 | # export to glyphNameData package 2 | 3 | import os, shutil 4 | 5 | root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.getcwd())))) 6 | path = os.path.join(root, "glyphData") 7 | if not os.path.exists(path): 8 | print(f"Please put the glyphData package at {path}") 9 | exit() 10 | 11 | print(path) 12 | 13 | destinationFolder = os.path.join(path, "Lib", "glyphData") 14 | sourceFolderLib = os.path.join(root, "glyphNameFormatter", "Lib", "glyphNameFormatter") 15 | 16 | # which file: 17 | # why : 18 | 19 | 20 | # which file: Lib/glyphNameFormatter/names/glyphNamesToUnicodeAndCategories_experimental.txt 21 | # why : this is the main names list 22 | 23 | nameFiles = ["glyphNamesToUnicodeAndCategories.txt"] 24 | for n in nameFiles: 25 | src = os.path.join(sourceFolderLib, "names", n) 26 | dst = os.path.join(destinationFolder, n) 27 | print(f'copying {os.path.basename(src)} to {dst}') 28 | shutil.copy(src, dst) 29 | 30 | dataFiles = [ "joiningTypes.txt", 31 | "nameHistory.txt", 32 | "mirrored.py", 33 | ] 34 | for n in dataFiles: 35 | src = os.path.join(sourceFolderLib, "data", n) 36 | dst = os.path.join(destinationFolder, n) 37 | print(f'copying {os.path.basename(src)} to {dst}') 38 | shutil.copy(src, dst) 39 | 40 | dataFiles = [ "reader.py", 41 | ] 42 | for n in dataFiles: 43 | src = os.path.join(sourceFolderLib, n) 44 | dst = os.path.join(destinationFolder, n) 45 | print(f'copying {os.path.basename(src)} to {dst}') 46 | shutil.copy(src, dst) 47 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/supplemental_punctuation.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("QUESTION MARK", "question") 4 | self.edit("SQUARED", "square") 5 | self.edit("PARENTHESIS", "paren") 6 | self.edit("DOUBLE", "dbl") 7 | self.edit("WITH QUILL", "quill") 8 | self.edit("WITH DOT BELOW", "dotbelow") 9 | self.edit("WITH DOT ABOVE", "dotaccent") 10 | self.edit("WITH RING ABOVE", "ring") 11 | self.edit("WITH DIAERESIS", self.prefSpelling_dieresis) 12 | self.edit("DOWNWARDS", "down") 13 | self.edit("UPWARDS", "up") 14 | self.edit("RAISED OMISSION", "raised") 15 | 16 | self.replace("QUOTATION", "quote") 17 | self.replace("MARKER", "marker") 18 | self.edit("MARK") 19 | self.edit("PUNCTUATION") 20 | self.edit("SIDEWAYS") 21 | 22 | self.edit("LOW-REVERSED-9", "lowreversed") 23 | self.edit("TWO-", "dbl") 24 | self.edit("THREE-", "tpl") 25 | parts = [ 26 | "HALF", "DOTTED", "RAISED", "INTERPOLATION", "TRANSPOSITION", "SUBSTITUTION", 27 | "RING", "VERTICAL", "PARAPHRASE", "FORKED", "EDITORIAL", 28 | "REVERSED", "INVERTED", "OBLIQUE", 29 | "FOUR", 30 | "BOTTOM", "TOP", "LOW", 31 | "LEFT", "RIGHT", 32 | ] 33 | for part in parts: 34 | self.edit(part, part.lower()) 35 | 36 | self.replace("-POINTING") 37 | 38 | self.lower() 39 | self.compress() 40 | 41 | if __name__ == "__main__": 42 | from glyphNameFormatter.exporters import printRange 43 | printRange("Supplemental Punctuation") 44 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/03100-0312F bopomofo.txt: -------------------------------------------------------------------------------- 1 | # Bopomofo 03100 - 0312F 2 | 3105 bopo:b BOPOMOFO LETTER B 3 | 3106 bopo:p BOPOMOFO LETTER P 4 | 3107 bopo:m BOPOMOFO LETTER M 5 | 3108 bopo:f BOPOMOFO LETTER F 6 | 3109 bopo:d BOPOMOFO LETTER D 7 | 310A bopo:t BOPOMOFO LETTER T 8 | 310B bopo:n BOPOMOFO LETTER N 9 | 310C bopo:l BOPOMOFO LETTER L 10 | 310D bopo:g BOPOMOFO LETTER G 11 | 310E bopo:k BOPOMOFO LETTER K 12 | 310F bopo:h BOPOMOFO LETTER H 13 | 3110 bopo:j BOPOMOFO LETTER J 14 | 3111 bopo:q BOPOMOFO LETTER Q 15 | 3112 bopo:x BOPOMOFO LETTER X 16 | 3113 bopo:zh BOPOMOFO LETTER ZH 17 | 3114 bopo:ch BOPOMOFO LETTER CH 18 | 3115 bopo:sh BOPOMOFO LETTER SH 19 | 3116 bopo:r BOPOMOFO LETTER R 20 | 3117 bopo:z BOPOMOFO LETTER Z 21 | 3118 bopo:c BOPOMOFO LETTER C 22 | 3119 bopo:s BOPOMOFO LETTER S 23 | 311A bopo:a BOPOMOFO LETTER A 24 | 311B bopo:o BOPOMOFO LETTER O 25 | 311C bopo:e BOPOMOFO LETTER E 26 | 311D bopo:eh BOPOMOFO LETTER EH 27 | 311E bopo:ai BOPOMOFO LETTER AI 28 | 311F bopo:ei BOPOMOFO LETTER EI 29 | 3120 bopo:au BOPOMOFO LETTER AU 30 | 3121 bopo:ou BOPOMOFO LETTER OU 31 | 3122 bopo:an BOPOMOFO LETTER AN 32 | 3123 bopo:en BOPOMOFO LETTER EN 33 | 3124 bopo:ang BOPOMOFO LETTER ANG 34 | 3125 bopo:eng BOPOMOFO LETTER ENG 35 | 3126 bopo:er BOPOMOFO LETTER ER 36 | 3127 bopo:i BOPOMOFO LETTER I 37 | 3128 bopo:u BOPOMOFO LETTER U 38 | 3129 bopo:iu BOPOMOFO LETTER IU 39 | 312A bopo:v BOPOMOFO LETTER V 40 | 312B bopo:ng BOPOMOFO LETTER NG 41 | 312C bopo:gn BOPOMOFO LETTER GN 42 | 312D bopo:ih BOPOMOFO LETTER IH 43 | 312E bopo:owithdotabove BOPOMOFO LETTER O WITH DOT ABOVE 44 | 312F bopo:nn BOPOMOFO LETTER NN -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2016, LettError and Erik van Blokland, TypeMyType and Frederik Berlaen 2 | 3 | All rights reserved. 4 | 5 | Redistribution and use in source and binary forms, with or without modification, 6 | are permitted provided that the following conditions are met: 7 | 8 | 1. Redistributions of source code must retain the above copyright notice, 9 | this list of conditions and the following disclaimer. 10 | 11 | 2. Redistributions in binary form must reproduce the above copyright notice, 12 | this list of conditions and the following disclaimer in the documentation and/or 13 | other materials provided with the distribution. 14 | 15 | 3. Neither the name of the copyright holder nor the names of its contributors may 16 | be used to endorse or promote products derived from this software without specific 17 | prior written permission. 18 | 19 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 20 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 21 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 23 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 24 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 26 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 27 | OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 28 | OF THE POSSIBILITY OF SUCH DAMAGE. -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/mathematical_operators.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("THERE DOES NOT EXIST", "notexistential") 4 | self.replace("DOES NOT CONTAIN AS MEMBER", "notcontains") 5 | 6 | self.edit("DOUBLE", "dbl") 7 | self.edit("TRIPLE", "tpl") 8 | self.edit("CONTOUR", "contour") 9 | self.edit("SURFACE", "surface") 10 | self.edit("VOLUME", "volume") 11 | self.edit("ANTICLOCKWISE", "anticlockwise") 12 | self.edit("CLOCKWISE", "clockwise") 13 | self.edit("SMALL", "small") 14 | self.edit("N-ARY", "array") 15 | self.edit("REVERSED", "reversed") 16 | self.edit("INVERTED", "inverted") 17 | self.edit("MIDLINE", "mid") 18 | self.edit("VERTICAL BAR", "verticalbar") 19 | self.edit("VERTICAL", "vertical") 20 | self.edit("HORIZONTAL BAR", "horizontalbar") 21 | self.edit("HORIZONTAL", "horizontal") 22 | self.edit("DIAGONAL", "diagonal") 23 | self.edit("UP", "up") 24 | self.edit("DOWN", "down") 25 | self.edit("RIGHT", "right") 26 | self.edit("LEFT", "left") 27 | self.edit("STROKE", "stroke") 28 | 29 | self.replace("LESS-THAN", "less") 30 | self.replace("GREATER-THAN", "greater") 31 | self.replace("OPERATOR", "operator") 32 | self.replace("WITH") 33 | self.replace("LONG", "long") 34 | self.replace("SIGN") 35 | self.replace("-OR-") 36 | self.replace("TO") 37 | self.replace("THE") 38 | self.replace("AT END") 39 | self.replace("OF") 40 | 41 | self.lower() 42 | self.compress() 43 | 44 | 45 | if __name__ == "__main__": 46 | from glyphNameFormatter.exporters import printRange 47 | printRange("Mathematical Operators") 48 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/ipa_extensions.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.data.scriptPrefixes import scriptPrefixes 2 | 3 | def process(self): 4 | 5 | 6 | self.edit("LATIN") 7 | self.edit("OPEN", "open") 8 | self.edit("WITH FISHHOOK", "fishhook") 9 | self.edit("SCRIPT", "script") 10 | self.edit("WITH BELT", "belt") 11 | self.edit("WITH MIDDLE TILDE", "middletilde") 12 | self.edit("WITH LONG LEG", "longleg") 13 | self.edit("WITH CROSSED-TAIL", "crossedtail") 14 | self.edit("BILABIAL", "bilabial") 15 | self.edit("BIDENTAL", "bidental") 16 | self.edit("STRETCHED", "stretched") 17 | self.edit("WITH STROKE", "stroke") 18 | self.edit("SQUAT", "squat") 19 | self.edit("INVERTED", "inverted") 20 | self.edit("REVERSED", "reversed") 21 | 22 | self.replace("DZ", "dzed") 23 | self.replace("LZ", "lzed") 24 | self.replace("DIGRAPH") 25 | self.replace("PERCUSSIVE", "percussive") 26 | self.replace("GLOTTAL", "glottal") 27 | self.replace("STOP", "stop") 28 | self.replace("PHARYNGEAL", "pharyngeal") 29 | self.replace("VOICED", "voiced") 30 | self.replace("FRICATIVE", "fricative") 31 | 32 | self.replace("LETTER CLICK", "click") 33 | self.replace("LETTER GLOTTAL STOP WITH STROKE", "glottalstopstroke") 34 | self.replace("LETTER SMALL CAPITAL OE", "OEsmall") 35 | 36 | 37 | 38 | 39 | self.processAs("Helper Diacritics") 40 | self.processAs("Helper Shapes") 41 | 42 | self.handleCase() 43 | self.replace("LETTER") 44 | self.processAs("Helper Latin Greeks") 45 | self.compress() 46 | 47 | 48 | if __name__ == "__main__": 49 | from glyphNameFormatter.exporters import printRange 50 | printRange("IPA Extensions") 51 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/helper_latin_greeks.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.data.scriptPrefixes import scriptPrefixes 2 | 3 | # Some Greek letters make a guest appearance in the Latin ranges. 4 | # Some in Latin extended, some in IPa 5 | # This gives all these a separate script prefix, "ltgr" or "latingreek". 6 | # This designation has no linguistic value. By setting the "latingreek" 7 | # script, all these letters will get the same treatment. 8 | 9 | def process(self): 10 | latinGreeks = [ 11 | # these need to be prefixed as latin. 12 | 0x0251, # LATIN SMALL LETTER ALPHA 13 | 0x0263, # LATIN SMALL LETTER GAMMA 14 | 0x0269, # LATIN SMALL LETTER IOTA 15 | 0x0277, # LATIN SMALL LETTER CLOSED OMEGA 16 | 0x0278, # LATIN SMALL LETTER PHI 17 | 0xA7B3, # LATIN CAPITAL LETTER CHI 18 | 0xA7B4, # LATIN CAPITAL LETTER BETA 19 | 0xA7B5, # LATIN SMALL LETTER BETA 20 | 0xA7B5, # LATIN SMALL LETTER BETA 21 | 0xA7B6, # LATIN CAPITAL LETTER OMEGA 22 | 0xA7B7, # LATIN SMALL LETTER OMEGA 23 | 24 | 25 | 0xA7DA, # LATIN CAPITAL LETTER LAMBDA 26 | 0xA7DB, # LATIN SMALL LETTER LAMBDA 27 | 0xA7DC, # LATIN CAPITAL LETTER LAMBDA WITH STROKE 28 | 0xAB30, # ꬰ LATIN SMALL LETTER BARRED ALPHA 29 | 0xAB53, # ꭓ LATIN SMALL LETTER CHI 30 | 0xAB54, # ꭔ LATIN SMALL LETTER CHI WITH LOW RIGHT RING 31 | 0xAB55, # ꭕ LATIN SMALL LETTER CHI WITH LOW LEFT SERIF 32 | 0xAB64, # ꭤ LATIN SMALL LETTER INVERTED ALPHA 33 | 0xAB65, # ꭥ GREEK LETTER SMALL CAPITAL OMEGA 34 | ] 35 | 36 | if self.uniNumber in latinGreeks: 37 | self.scriptTag = scriptPrefixes['latingreek'] 38 | 39 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/02C60-02C7F latin_extended-c.txt: -------------------------------------------------------------------------------- 1 | # Latin Extended-C 02C60 - 02C7F 2 | 2C60 Ldblbar LATIN CAPITAL LETTER L WITH DOUBLE BAR 3 | 2C61 ldblbar LATIN SMALL LETTER L WITH DOUBLE BAR 4 | 2C62 Lmiddletilde LATIN CAPITAL LETTER L WITH MIDDLE TILDE 5 | 2C63 Pstroke LATIN CAPITAL LETTER P WITH STROKE 6 | 2C64 Rtail LATIN CAPITAL LETTER R WITH TAIL 7 | 2C65 astroke LATIN SMALL LETTER A WITH STROKE 8 | 2C66 tstroke LATIN SMALL LETTER T WITH DIAGONAL STROKE 9 | 2C67 Hdescender LATIN CAPITAL LETTER H WITH DESCENDER 10 | 2C68 hdescender LATIN SMALL LETTER H WITH DESCENDER 11 | 2C69 Kdescender LATIN CAPITAL LETTER K WITH DESCENDER 12 | 2C6A kdescender LATIN SMALL LETTER K WITH DESCENDER 13 | 2C6B Zdescender LATIN CAPITAL LETTER Z WITH DESCENDER 14 | 2C6C zdescender LATIN SMALL LETTER Z WITH DESCENDER 15 | 2C6D lt:Alpha LATIN CAPITAL LETTER ALPHA 16 | 2C6E Mhook LATIN CAPITAL LETTER M WITH HOOK 17 | 2C6F Aturned LATIN CAPITAL LETTER TURNED A 18 | 2C70 lt:Alphaturned LATIN CAPITAL LETTER TURNED ALPHA 19 | 2C71 vrighthook LATIN SMALL LETTER V WITH RIGHT HOOK 20 | 2C72 Whook LATIN CAPITAL LETTER W WITH HOOK 21 | 2C73 whook LATIN SMALL LETTER W WITH HOOK 22 | 2C74 vcurl LATIN SMALL LETTER V WITH CURL 23 | 2C75 Hhalf LATIN CAPITAL LETTER HALF H 24 | 2C76 hhalf LATIN SMALL LETTER HALF H 25 | 2C77 phitailless LATIN SMALL LETTER TAILLESS PHI 26 | 2C78 enotch LATIN SMALL LETTER E WITH NOTCH 27 | 2C79 rtailturned LATIN SMALL LETTER TURNED R WITH TAIL 28 | 2C7A olowringinside LATIN SMALL LETTER O WITH LOW RING INSIDE 29 | 2C7B Esmallturned LATIN LETTER SMALL CAPITAL TURNED E 30 | 2C7C j.inferior LATIN SUBSCRIPT SMALL LETTER J 31 | 2C7D Vmod MODIFIER LETTER CAPITAL V 32 | 2C7E Sswashtail LATIN CAPITAL LETTER S WITH SWASH TAIL 33 | 2C7F Zswashtail LATIN CAPITAL LETTER Z WITH SWASH TAIL -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/helper_arabic_ligature_exceptions.py: -------------------------------------------------------------------------------- 1 | from __future__ import print_function 2 | from glyphNameFormatter.tools import camelCase 3 | 4 | 5 | doNotProcessAsLigatureRanges = [ 6 | (0xfc5e, 0xfc63), 7 | (0xfe70, 0xfe74), 8 | #(0xfc5e, 0xfc61), 9 | (0xfcf2, 0xfcf4), 10 | (0xfe76, 0xfe80), 11 | ] 12 | 13 | 14 | def process(self): 15 | # Specifically: do not add suffixes to these ligatures, 16 | # they're really arabic marks 17 | 18 | for a, b in doNotProcessAsLigatureRanges: 19 | if a <= self.uniNumber <= b: 20 | self.replace('TAIL FRAGMENT', "kashida Fina") 21 | self.replace('INITIAL FORM', "init") 22 | self.replace('MEDIAL FORM', "medi") 23 | self.replace('FINAL FORM', "fina") 24 | self.replace('ISOLATED FORM', "isol") 25 | self.replace('WITH SUPERSCRIPT', "") 26 | self.replace('WITH', "") 27 | self.replace("LIGATURE", "") 28 | self.replace("ARABIC", "") 29 | self.replace("SYMBOL", "") 30 | self.replace("LETTER", "") 31 | self.lower() 32 | self.camelCase() 33 | return True 34 | 35 | return False 36 | 37 | 38 | if __name__ == "__main__": 39 | from glyphNameFormatter import GlyphName 40 | 41 | print("\ndoNotProcessAsLigatureRanges", doNotProcessAsLigatureRanges) 42 | odd = 0xfe76 43 | for a, b in doNotProcessAsLigatureRanges: 44 | for u in range(a,b+1): 45 | try: 46 | g = GlyphName(uniNumber=u) 47 | n = g.getName() 48 | print(hex(u), n, g.uniName) 49 | 50 | except: 51 | import traceback 52 | traceback.print_exc() 53 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/02D00-02D2F georgian_supplement.txt: -------------------------------------------------------------------------------- 1 | # Georgian Supplement 02D00 - 02D2F 2 | 2D00 anGeok GEORGIAN SMALL LETTER AN 3 | 2D01 banGeok GEORGIAN SMALL LETTER BAN 4 | 2D02 ganGeok GEORGIAN SMALL LETTER GAN 5 | 2D03 donGeok GEORGIAN SMALL LETTER DON 6 | 2D04 enGeok GEORGIAN SMALL LETTER EN 7 | 2D05 vinGeok GEORGIAN SMALL LETTER VIN 8 | 2D06 zenGeok GEORGIAN SMALL LETTER ZEN 9 | 2D07 tanGeok GEORGIAN SMALL LETTER TAN 10 | 2D08 inGeok GEORGIAN SMALL LETTER IN 11 | 2D09 kanGeok GEORGIAN SMALL LETTER KAN 12 | 2D0A lasGeok GEORGIAN SMALL LETTER LAS 13 | 2D0B manGeok GEORGIAN SMALL LETTER MAN 14 | 2D0C narGeok GEORGIAN SMALL LETTER NAR 15 | 2D0D onGeok GEORGIAN SMALL LETTER ON 16 | 2D0E parGeok GEORGIAN SMALL LETTER PAR 17 | 2D0F zharGeok GEORGIAN SMALL LETTER ZHAR 18 | 2D10 raeGeok GEORGIAN SMALL LETTER RAE 19 | 2D11 sanGeok GEORGIAN SMALL LETTER SAN 20 | 2D12 tarGeok GEORGIAN SMALL LETTER TAR 21 | 2D13 unGeok GEORGIAN SMALL LETTER UN 22 | 2D14 pharGeok GEORGIAN SMALL LETTER PHAR 23 | 2D15 kharGeok GEORGIAN SMALL LETTER KHAR 24 | 2D16 ghanGeok GEORGIAN SMALL LETTER GHAN 25 | 2D17 qarGeok GEORGIAN SMALL LETTER QAR 26 | 2D18 shinGeok GEORGIAN SMALL LETTER SHIN 27 | 2D19 chinGeok GEORGIAN SMALL LETTER CHIN 28 | 2D1A canGeok GEORGIAN SMALL LETTER CAN 29 | 2D1B jilGeok GEORGIAN SMALL LETTER JIL 30 | 2D1C cilGeok GEORGIAN SMALL LETTER CIL 31 | 2D1D charGeok GEORGIAN SMALL LETTER CHAR 32 | 2D1E xanGeok GEORGIAN SMALL LETTER XAN 33 | 2D1F jhanGeok GEORGIAN SMALL LETTER JHAN 34 | 2D20 haeGeok GEORGIAN SMALL LETTER HAE 35 | 2D21 heGeok GEORGIAN SMALL LETTER HE 36 | 2D22 hieGeok GEORGIAN SMALL LETTER HIE 37 | 2D23 weGeok GEORGIAN SMALL LETTER WE 38 | 2D24 harGeok GEORGIAN SMALL LETTER HAR 39 | 2D25 hoeGeok GEORGIAN SMALL LETTER HOE 40 | 2D27 ynGeok GEORGIAN SMALL LETTER YN 41 | 2D2D aenGeok GEORGIAN SMALL LETTER AEN -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/spacing_modifier_letters.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.scriptTag = "" 5 | if self.has("MODIFIER LETTER CIRCUMFLEX ACCENT"): 6 | return 7 | 8 | self.replace("MODIFIER") 9 | 10 | # self.replace("LETTER SMALL CAPITAL INVERTED R", "Rsmallinvertedsupmod") 11 | 12 | self.edit("COLON", "colon") 13 | self.edit("TRIANGULAR", "triangular") 14 | self.edit("RING", "ring") 15 | self.edit("DEPARTING TONE MARK", "tone") 16 | self.edit("TONE MARK", "tone") 17 | self.edit("TONE", "tone") 18 | self.edit("DOUBLE", "dbl") 19 | self.edit("WITH HOOK", "hook") 20 | self.edit("HOOK", "hook") 21 | self.edit("TURNED", "turned") 22 | self.edit("HALF", "half") 23 | self.edit("SMALL", "sup") 24 | self.edit("BAR", "bar") 25 | self.edit("HALF", "half") 26 | self.edit("LEFT", "left") 27 | self.edit("RIGHT", "right") 28 | self.edit("UP", "up") 29 | self.edit("DOWN", "down") 30 | self.edit("EXTRA-LOW", "extralow") 31 | self.edit("LOW", "low") 32 | self.edit("MIDDLE", "middle") 33 | self.edit("MID", "mid") 34 | self.edit("EXTRA-HIGH", "extrahigh") 35 | self.edit("HIGH", "high") 36 | self.edit("BEGIN", "begin") 37 | self.edit("END", "end") 38 | 39 | self.edit("RAISED", "raised") 40 | self.edit("SHELF", "shelf") 41 | 42 | self.processAs("Helper Shapes") 43 | 44 | self.replace("ACCENT") 45 | self.replace("LETTER") 46 | 47 | self.handleCase() 48 | if not self.has("CAPITAL"): 49 | self.lower() 50 | if self.has("MODIFIER"): 51 | self.suffix("mod") 52 | self.compress() 53 | 54 | 55 | 56 | if __name__ == "__main__": 57 | from glyphNameFormatter.exporters import printRange 58 | printRange("Spacing Modifier Letters") 59 | 60 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/tools.py: -------------------------------------------------------------------------------- 1 | import struct 2 | 3 | 4 | def camelCase(pattern): 5 | if len(pattern) == 0: 6 | return "" 7 | if "-" in pattern: 8 | t = "" 9 | for p in pattern.split("-"): 10 | t += camelCase(p) 11 | return t 12 | return pattern[0].upper()+pattern[1:].lower() 13 | 14 | 15 | def unicodeToChar(uni): 16 | if uni < 0xFFFF: 17 | return chr(uni) 18 | else: 19 | return struct.pack('i', uni).decode('utf-32') 20 | 21 | 22 | def charToUnicode(char): 23 | if len(char) != 2: 24 | return ord(char) 25 | return 0x10000 + (ord(char[0]) - 0xD800) * 0x400 + (ord(char[1]) - 0xDC00) 26 | 27 | 28 | def debug(uniNumber): 29 | # dump the steps of building the name 30 | import glyphNameFormatter 31 | g = glyphNameFormatter.GlyphName(uniNumber) 32 | name = g.getName(extension=True) 33 | count = 0 34 | print("Debugging: %s" % name) 35 | print("uninumber: %04X" % uniNumber) 36 | print("uni range: %s" % g.uniRangeName) 37 | cols = "{0:<5} {1:<40} {2:<40} {3:<40} {4:<40} {5:<50}" 38 | print(cols.format("Step", "Look For", "Replace With", "Before", "After", "Suffixen")) 39 | for lookFor, replaceWith, before, after in g._log: 40 | count += 1 41 | print(cols.format(count, lookFor, replaceWith, before, after, ", ".join(g.suffixParts))) 42 | print("\nSuffixes: %s" % " ".join(g.suffixParts)) 43 | 44 | 45 | class GlyphNameFormatterError(Exception): 46 | pass 47 | 48 | 49 | if __name__ == "__main__": 50 | assert camelCase("aaaa") == "Aaaa" 51 | assert camelCase("aaaA") == "Aaaa" 52 | assert camelCase("aaaa-aaaa") == "AaaaAaaa" 53 | assert camelCase("aaaa-") == "Aaaa" 54 | assert camelCase("-") == "" 55 | assert camelCase("") == "" 56 | 57 | debug(0x0300) 58 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/basic_latin.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("LATIN") 4 | if self.has("DIGIT"): 5 | self.edit("DIGIT", "") 6 | self.lower() 7 | self.edit("SPACE", "space") 8 | self.edit("EXCLAMATION MARK", "exclam") 9 | self.edit("QUESTION MARK", "question") 10 | self.edit("QUOTATION MARK", "quotedbl") 11 | self.edit("NUMBER SIGN", "numbersign") 12 | self.edit("DOLLAR SIGN", "dollar") 13 | self.edit("PERCENT SIGN", "percent") 14 | self.edit("PLUS SIGN", "plus") 15 | self.edit("SEMICOLON", "semicolon") 16 | self.edit("MULTIPLICATION SIGN", "multiply") 17 | self.edit("DIVISION SIGN", "divide") 18 | self.edit("COLON", "colon") 19 | self.edit("COMMA", "comma") 20 | self.edit("EQUALS SIGN", "equal") 21 | self.edit("LESS-THAN SIGN", "less") 22 | self.edit("GREATER-THAN SIGN", "greater") 23 | self.edit("REVERSE SOLIDUS", "backslash") 24 | self.edit("SOLIDUS", "slash") 25 | self.edit("VERTICAL LINE", "bar") 26 | self.edit("HYPHEN-MINUS", "hyphen") 27 | self.edit("AMPERSAND", "ampersand") 28 | self.edit("ASTERISK", "asterisk") 29 | self.edit("APOSTROPHE", "quotesingle") 30 | self.edit("FULL STOP", "period") 31 | self.edit("LOW LINE", "underscore") 32 | self.edit("CIRCUMFLEX ACCENT", "asciicircum") 33 | self.edit("GRAVE ACCENT", "grave") 34 | self.edit("TILDE", "asciitilde") 35 | 36 | self.edit("SQUARE BRACKET", "bracket") 37 | self.edit("CURLY BRACKET", "brace") 38 | self.edit("PARENTHESIS", "parenthesis") 39 | self.edit("LEFT", "left") 40 | if self.has("RIGHT") and not self.has("COPYRIGHT"): 41 | self.edit("RIGHT", "right") 42 | self.handleCase() 43 | 44 | if __name__ == "__main__": 45 | from glyphNameFormatter.exporters import printRange 46 | printRange("Basic Latin") 47 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/latin_extended_b.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | self.edit("LATIN") 5 | 6 | self.replace("CAPITAL LETTER D WITH SMALL LETTER Z", "Dz") 7 | self.replace("CAPITAL LETTER DZ", "DZ") 8 | 9 | self.edit("AFRICAN", "african") 10 | 11 | self.edit("WITH LONG RIGHT LEG", "long", "right", "leg") 12 | self.edit('LETTER YR', "yr") 13 | self.edit("CAPITAL LETTER O WITH MIDDLE TILDE", "Obar") 14 | self.edit("CAPITAL LETTER SMALL Q WITH HOOK TAIL", "Qsmallhooktail") 15 | self.edit("LETTER REVERSED ESH LOOP", "eshreversedloop") 16 | self.edit("CAPITAL LETTER L WITH SMALL LETTER J", "Lj") 17 | self.edit("CAPITAL LETTER N WITH SMALL LETTER J", "Nj") 18 | self.edit("LETTER INVERTED GLOTTAL STOP WITH STROKE", "glottalinvertedstroke") 19 | self.edit("LETTER TWO WITH STROKE", "twostroke") 20 | 21 | self.edit("CAPITAL LETTER LJ", "LJ") 22 | self.edit("CAPITAL LETTER NJ", "NJ") 23 | self.edit("CAPITAL LETTER AE WITH", "AE") 24 | 25 | self.edit("CAPITAL LETTER WYNN", "Wynn") 26 | self.edit("LETTER WYNN", "wynn") 27 | 28 | self.edit("WITH PALATAL", "palatal") 29 | self.edit("DENTAL", "dental") 30 | self.edit("LATERAL", "lateral") 31 | self.edit("ALVEOLAR", "alveolar") 32 | self.edit("RETROFLEX", "retroflex") 33 | 34 | self.replace("LETTER CLICK", "click") 35 | 36 | self.forceScriptPrefix("latin", "CAPITAL LETTER GAMMA", "Gamma") 37 | self.forceScriptPrefix("latin", "CAPITAL LETTER IOTA", "Iota") 38 | self.forceScriptPrefix("latin", "CAPITAL LETTER UPSILON", "Upsilon") 39 | 40 | self.processAs("Helper Diacritics") 41 | self.processAs("Helper Shapes") 42 | 43 | self.handleCase() 44 | self.compress() 45 | 46 | 47 | if __name__ == "__main__": 48 | from glyphNameFormatter.exporters import printRange 49 | printRange("Latin Extended-B") 50 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/02580-0259F block_elements.txt: -------------------------------------------------------------------------------- 1 | # Block Elements 02580 - 0259F 2 | 2580 upperHalfBlock UPPER HALF BLOCK 3 | 2581 lowerOneEighthBlock LOWER ONE EIGHTH BLOCK 4 | 2582 lowerOneQuarterBlock LOWER ONE QUARTER BLOCK 5 | 2583 lowerThreeEighthsBlock LOWER THREE EIGHTHS BLOCK 6 | 2584 lowerHalfBlock LOWER HALF BLOCK 7 | 2585 lowerFiveEighthsBlock LOWER FIVE EIGHTHS BLOCK 8 | 2586 lowerThreeQuartersBlock LOWER THREE QUARTERS BLOCK 9 | 2587 lowerSevenEighthsBlock LOWER SEVEN EIGHTHS BLOCK 10 | 2588 fullBlock FULL BLOCK 11 | 2589 leftSevenEighthsBlock LEFT SEVEN EIGHTHS BLOCK 12 | 258A leftThreeQuartersBlock LEFT THREE QUARTERS BLOCK 13 | 258B leftFiveEighthsBlock LEFT FIVE EIGHTHS BLOCK 14 | 258C leftHalfBlock LEFT HALF BLOCK 15 | 258D leftThreeEighthsBlock LEFT THREE EIGHTHS BLOCK 16 | 258E leftOneQuarterBlock LEFT ONE QUARTER BLOCK 17 | 258F leftOneEighthBlock LEFT ONE EIGHTH BLOCK 18 | 2590 rightHalfBlock RIGHT HALF BLOCK 19 | 2591 lightShade LIGHT SHADE 20 | 2592 mediumShade MEDIUM SHADE 21 | 2593 darkShade DARK SHADE 22 | 2594 upperOneEighthBlock UPPER ONE EIGHTH BLOCK 23 | 2595 rightOneEighthBlock RIGHT ONE EIGHTH BLOCK 24 | 2596 quadrantLowerLeft QUADRANT LOWER LEFT 25 | 2597 quadrantLowerRight QUADRANT LOWER RIGHT 26 | 2598 quadrantUpperLeft QUADRANT UPPER LEFT 27 | 2599 quadrantUpperLeftAndLowerLeftAndLowerRight QUADRANT UPPER LEFT AND LOWER LEFT AND LOWER RIGHT 28 | 259A quadrantUpperLeftAndLowerRight QUADRANT UPPER LEFT AND LOWER RIGHT 29 | 259B quadrantUpperLeftAndUpperRightAndLowerLeft QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER LEFT 30 | 259C quadrantUpperLeftAndUpperRightAndLowerRight QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER RIGHT 31 | 259D quadrantUpperRight QUADRANT UPPER RIGHT 32 | 259E quadrantUpperRightAndLowerLeft QUADRANT UPPER RIGHT AND LOWER LEFT 33 | 259F quadrantUpperRightAndLowerLeftAndLowerRight QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/latin_extended_a.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("LATIN") 4 | 5 | self.edit("CAPITAL LETTER G WITH CEDILLA", "Gcommaaccent") 6 | self.edit("SMALL LETTER G WITH CEDILLA", "gcommaaccent") 7 | self.edit("CAPITAL LETTER H WITH STROKE", "Hbar") 8 | self.edit("SMALL LETTER H WITH STROKE", "hbar") 9 | self.edit("CAPITAL LETTER K WITH CEDILLA", "Kcommaaccent") 10 | self.edit("SMALL LETTER K WITH CEDILLA", "kcommaaccent") 11 | self.edit("CAPITAL LETTER L WITH CEDILLA", "Lcommaaccent") 12 | self.edit("SMALL LETTER L WITH CEDILLA", "lcommaaccent") 13 | self.edit("CAPITAL LETTER N WITH CEDILLA", "Ncommaaccent") 14 | self.edit("SMALL LETTER N WITH CEDILLA", "ncommaaccent") 15 | self.edit("CAPITAL LETTER R WITH CEDILLA", "Rcommaaccent") 16 | self.edit("SMALL LETTER R WITH CEDILLA", "rcommaaccent") 17 | self.edit("CAPITAL LETTER T WITH STROKE", "Tbar") 18 | self.edit("SMALL LETTER T WITH STROKE", "tbar") 19 | self.edit("CAPITAL LETTER L WITH STROKE", "Lslash") 20 | self.edit("SMALL LETTER L WITH STROKE", "lslash") 21 | self.edit("CAPITAL LETTER D WITH STROKE", "Dcroat") 22 | self.edit("SMALL LETTER D WITH STROKE", "dcroat") 23 | 24 | self.edit("WITH DOUBLE ACUTE", "hungarumlaut") 25 | 26 | self.edit("SMALL LETTER L WITH MIDDLE DOT", "ldot") 27 | self.edit("CAPITAL LETTER L WITH MIDDLE DOT", "Ldot") 28 | 29 | self.replace("CAPITAL LIGATURE IJ", "IJ") 30 | self.replace("SMALL LIGATURE IJ", "ij") 31 | 32 | self.replace("SMALL LIGATURE OE", "oe") 33 | self.replace("CAPITAL LIGATURE OE", "OE") 34 | 35 | self.processAs("Helper Diacritics") 36 | 37 | self.editSuffix("dot", 'dotaccent') 38 | self.handleCase() 39 | self.compress() 40 | 41 | 42 | if __name__ == "__main__": 43 | from glyphNameFormatter.exporters import printRange 44 | printRange("Latin Extended-A") 45 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/miscellaneous_technical.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | # edits go here 4 | # self.edit("ARMENIAN") 5 | # self.handleCase() 6 | self.edit("X IN A RECTANGLE BOX", "clear") 7 | 8 | self.edit("UPPER LEFT OR LOWER RIGHT", "upleftlowerright") 9 | self.edit("UPPER RIGHT OR LOWER LEFT", "uprightlowerleft") 10 | 11 | self.edit("SYMBOL") 12 | self.edit("WITH") 13 | self.edit("LIGHT") 14 | self.edit("LINE-") 15 | self.edit("BETWEEN") 16 | self.edit("KEY") 17 | self.edit("TO THE") 18 | self.edit("APL") 19 | self.edit("I-BEAM", "beam") 20 | self.edit("LESS-THAN", "less") 21 | self.edit("GREATER-THAN", "greater") 22 | 23 | self.edit("UPWARDS", "up") 24 | self.edit("UPPER", "up") 25 | self.edit("DOWNWARDS", "down") 26 | self.edit("LEFTWARDS", "left") 27 | self.edit("RIGHTWARDS", "right") 28 | 29 | self.replace("UNDERBAR", "underline") 30 | 31 | self.edit("TORTOISE SHELL", "shell") 32 | self.replace("PARENTHESIS", "paren") 33 | 34 | self.edit("OPEN-CIRCUIT-OUTPUT", "opencircuit") 35 | self.edit("PASSIVE-PULL-DOWN-OUTPUT", "passivedown") 36 | self.edit("PASSIVE-PULL-UP", "passiveup") 37 | self.replace("-TYPE", "type") 38 | 39 | parts = [ 40 | "UP", "DOWN", "TOP", "BOTTOM", 41 | "TURNED", 42 | "HORIZONTAL", "VERTICAL", 43 | "LEFT", "RIGHT", 44 | "SQUARE", "CURLY", 45 | "METRICAL", 46 | "WHITE", 47 | ] 48 | for part in parts: 49 | self.edit(part, part.lower()) 50 | 51 | self.processAs("helper_numbers") 52 | 53 | self.edit("FUNCTIONAL", "func") 54 | 55 | self.edit("AND") 56 | self.edit("-") 57 | 58 | self.lower() 59 | self.compress() 60 | 61 | if __name__ == "__main__": 62 | from glyphNameFormatter.exporters import printRange 63 | printRange("Miscellaneous Technical") 64 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/latin_extended_d.py: -------------------------------------------------------------------------------- 1 | from glyphNameFormatter.data.scriptPrefixes import scriptPrefixes 2 | 3 | def process(self): 4 | # edits go here 5 | self.edit("LATIN") 6 | 7 | self.replace("MODIFIER LETTER LOW CIRCUMFLEX ACCENT", "circumflexlow") 8 | 9 | 10 | self.edit("MODIFIER", "mod") 11 | self.edit("REVERSED", "reversed") 12 | self.replace("EGYPTOLOGICAL", "egypt") 13 | 14 | self.edit("WITH HORIZONTAL", "horizontal") 15 | self.edit("HORIZONTAL", "horizontal") 16 | self.edit("BROKEN", "broken") 17 | self.edit("INSULAR", "insular") 18 | self.edit("EPIGRAPHIC", "epigraphic") 19 | 20 | self.replace("WITH STROKE THROUGH DESCENDER", "strokedescender") 21 | self.replace("WITH DOT", "dot") 22 | self.replace("WITH STROKE", "stroke") 23 | self.replace("WITH DIAGONAL", "diagonal") 24 | self.replace("WITH SQUIRREL TAIL", "tail") 25 | 26 | self.edit("SIGN") 27 | self.replace("SHORT", "short") 28 | 29 | self.processAs("Helper Diacritics") 30 | self.processAs("Helper Shapes") 31 | 32 | self.edit("LONG") 33 | self.edit("OVERLAY") 34 | self.edit("HIGH") 35 | self.edit("AND") 36 | self.edit("WITH") 37 | 38 | allCaps = [ 39 | "AA", "AO", "AU", "AV", "AY", 40 | "OO" 41 | ] 42 | shouldHandleShape = True 43 | for cap in allCaps: 44 | if self.has("CAPITAL LETTER %s" % cap): 45 | shouldHandleShape = False 46 | 47 | if shouldHandleShape: 48 | self.handleCase() 49 | else: 50 | self.replace("CAPITAL") 51 | 52 | self.processAs("Helper Latin Greeks") 53 | 54 | 55 | 56 | self.edit("LETTER") 57 | 58 | 59 | if not self.has("CAPITAL"): 60 | self.lower() 61 | 62 | self.compress() 63 | 64 | if __name__ == "__main__": 65 | from glyphNameFormatter.exporters import printRange 66 | printRange("Latin Extended-D") 67 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/02070-0209F superscripts_and_subscripts.txt: -------------------------------------------------------------------------------- 1 | # Superscripts and Subscripts 02070 - 0209F 2 | 2070 zero.superior SUPERSCRIPT ZERO 3 | 2071 i.superior SUPERSCRIPT LATIN SMALL LETTER I 4 | 2074 four.superior SUPERSCRIPT FOUR 5 | 2075 five.superior SUPERSCRIPT FIVE 6 | 2076 six.superior SUPERSCRIPT SIX 7 | 2077 seven.superior SUPERSCRIPT SEVEN 8 | 2078 eight.superior SUPERSCRIPT EIGHT 9 | 2079 nine.superior SUPERSCRIPT NINE 10 | 207A plus.superior SUPERSCRIPT PLUS SIGN 11 | 207B minus.superior SUPERSCRIPT MINUS 12 | 207C equal.superior SUPERSCRIPT EQUALS SIGN 13 | 207D parenleft.superior SUPERSCRIPT LEFT PARENTHESIS 14 | 207E parenright.superior SUPERSCRIPT RIGHT PARENTHESIS 15 | 207F n.superior SUPERSCRIPT LATIN SMALL LETTER N 16 | 2080 zero.inferior SUBSCRIPT ZERO 17 | 2081 one.inferior SUBSCRIPT ONE 18 | 2082 two.inferior SUBSCRIPT TWO 19 | 2083 three.inferior SUBSCRIPT THREE 20 | 2084 four.inferior SUBSCRIPT FOUR 21 | 2085 five.inferior SUBSCRIPT FIVE 22 | 2086 six.inferior SUBSCRIPT SIX 23 | 2087 seven.inferior SUBSCRIPT SEVEN 24 | 2088 eight.inferior SUBSCRIPT EIGHT 25 | 2089 nine.inferior SUBSCRIPT NINE 26 | 208A plus.inferior SUBSCRIPT PLUS SIGN 27 | 208B minus.inferior SUBSCRIPT MINUS 28 | 208C equal.inferior SUBSCRIPT EQUALS SIGN 29 | 208D parenleft.inferior SUBSCRIPT LEFT PARENTHESIS 30 | 208E parenright.inferior SUBSCRIPT RIGHT PARENTHESIS 31 | 2090 a.inferior LATIN SUBSCRIPT SMALL LETTER A 32 | 2091 e.inferior LATIN SUBSCRIPT SMALL LETTER E 33 | 2092 o.inferior LATIN SUBSCRIPT SMALL LETTER O 34 | 2093 x.inferior LATIN SUBSCRIPT SMALL LETTER X 35 | 2094 schwa.inferior LATIN SUBSCRIPT SMALL LETTER SCHWA 36 | 2095 h.inferior LATIN SUBSCRIPT SMALL LETTER H 37 | 2096 k.inferior LATIN SUBSCRIPT SMALL LETTER K 38 | 2097 l.inferior LATIN SUBSCRIPT SMALL LETTER L 39 | 2098 m.inferior LATIN SUBSCRIPT SMALL LETTER M 40 | 2099 n.inferior LATIN SUBSCRIPT SMALL LETTER N 41 | 209A p.inferior LATIN SUBSCRIPT SMALL LETTER P 42 | 209B s.inferior LATIN SUBSCRIPT SMALL LETTER S 43 | 209C t.inferior LATIN SUBSCRIPT SMALL LETTER T -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/miscellaneous_symbols_and_pictographs.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("EMOJI MODIFIER FITZPATRICK TYPE-1-2", "fitz Patrick Type 1 2") 4 | self.replace("EMOJI MODIFIER FITZPATRICK TYPE-3", "fitz Patrick Type 3") 5 | self.replace("EMOJI MODIFIER FITZPATRICK TYPE-4", "fitz Patrick Type 4") 6 | self.replace("EMOJI MODIFIER FITZPATRICK TYPE-5", "fitz Patrick Type 5") 7 | self.replace("EMOJI MODIFIER FITZPATRICK TYPE-6", "fitz Patrick Type 6") 8 | 9 | self.replace("-", " ") 10 | self.replace("EUROPE-AFRICA", "Europe Africa") 11 | self.replace("ASIA-AUSTRALIA", "Asia Australia") 12 | self.edit("INPUT SYMBOL FOR SYMBOLS", "inputSymbols") 13 | self.edit("INPUT SYMBOL FOR NUMBERS", "inputNumbers") 14 | self.edit("INPUT SYMBOL FOR LATIN CAPITAL LETTERS", "inputCapLatin") 15 | self.edit("INPUT SYMBOL FOR LATIN SMALL LETTERS", "inputSmallLatin") 16 | self.edit("INPUT SYMBOL FOR LATIN LETTERS", "inputLatin") 17 | 18 | self.edit("SYMBOL", "") 19 | self.replace("FORK AND KNIFE", "fork knife") 20 | self.replace("BELL", "BellSymbol") 21 | self.replace("WITH PLATE", "plate") 22 | self.replace("SNOW CAPPED", "snowcapped") 23 | self.edit("WITH", "") 24 | self.replace("JACK-O-LANTERN", "jack O Lantern") 25 | self.edit("UP-POINTING", "Up") 26 | self.edit("DOWN-POINTING", "Down") 27 | self.replace("PERFORMING", "Performing") 28 | self.replace("CLOCK FACE", "clock ") 29 | self.replace("UPWARDS", "Up") 30 | self.replace("DOWNWARDS", "Down") 31 | self.edit("OCLOCK", "") 32 | self.replace("WITH YEN SIGN", "Yen") 33 | self.replace("WITH DOLLAR SIGN", "Dollar") 34 | self.replace("WITH EURO SIGN", "Euro") 35 | self.replace("WITH POUND SIGN", "Pound") 36 | 37 | self.edit("FOR", "") 38 | if self.uniNumber == 0x1F48D: 39 | self.forceScriptPrefix("Miscellaneous Symbols and Pictographs") 40 | 41 | 42 | self.camelCase() 43 | 44 | if __name__ == "__main__": 45 | from glyphNameFormatter.exporters import printRange 46 | printRange("Miscellaneous Symbols and Pictographs") 47 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/phonetic_extensions.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def process(self): 4 | # edits go here 5 | self.edit("LATIN") 6 | 7 | self.edit("WITH") 8 | 9 | parts = [ 10 | "OPEN", "STROKE", "TURNED", "REVERSED", 11 | "SIDEWAYS", "SUBSCRIPT", 12 | "TOP", "BOTTOM", 13 | "RETROFLEX", "SCRIPT", 14 | "HALF", "INSULAR", 15 | "VOICED", "LARYNGEAL", 16 | ] 17 | for part in parts: 18 | self.edit(part, part.lower()) 19 | 20 | self.edit("BARRED", "bar") 21 | self.edit("STRIKETHROUGH", "strike") 22 | self.edit("DIAERESIZED", self.prefSpelling_dieresis+"ed") 23 | 24 | self.replace("SPIRANT", "spirant") 25 | self.replace("LAMDA", "lambda") 26 | self.replace("LETTER SMALL CAPITAL L", "Lsmall") 27 | self.replace("LETTER SMALL CAPITAL N", "Nsmall") 28 | self.replace("LETTER SMALL CAPITAL R", "Rsmall") 29 | self.replace("SMALL CAPITAL LETTER U", "Usmall") 30 | self.replace("SMALL CAPITAL LETTER I", "Ismall") 31 | self.replace("LETTER SMALL CAPITAL EL", "Elsmall") 32 | 33 | if self.has("AIN"): 34 | # this is a conflic with ARABIC LETTER AIN 35 | # and we prefer to not have the prefix in arabic 36 | self.replace("AIN", "ain") 37 | self.scriptPrefix() 38 | 39 | self.replace("LETTER SMALL CAPITAL AE", "AEsmall") 40 | self.replace("LETTER SMALL CAPITAL OU", "OUsmall") 41 | 42 | self.edit("FISHHOOK AND MIDDLE TILDE", "fishmiddletilde") 43 | self.processAs("Helper Diacritics") 44 | 45 | if self.has("GREEK"): 46 | self.edit("GREEK") 47 | self.forceScriptPrefix("greek") 48 | self.handleCase() 49 | elif self.has("CYRILLIC"): 50 | self.edit("CYRILLIC") 51 | self.handleCase() 52 | self.forceScriptPrefix("cyrillic") 53 | else: 54 | self.handleCase() 55 | 56 | self.edit("MODIFIER", "mod") 57 | self.edit("LETTER") 58 | 59 | self.compress() 60 | #self.scriptPrefix() 61 | 62 | if __name__ == "__main__": 63 | from glyphNameFormatter.exporters import printRange 64 | printRange("Phonetic Extensions") 65 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/020D0-020FF combining_diacritical_marks_for_symbols.txt: -------------------------------------------------------------------------------- 1 | # Combining Diacritical Marks for Symbols 020D0 - 020FF 2 | 20D0 leftHarpoonAbovecmb COMBINING LEFT HARPOON ABOVE 3 | 20D1 rightHarpoonAbovecmb COMBINING RIGHT HARPOON ABOVE 4 | 20D2 longVerticalLineOverlaycmb COMBINING LONG VERTICAL LINE OVERLAY 5 | 20D3 shortVerticalLineOverlaycmb COMBINING SHORT VERTICAL LINE OVERLAY 6 | 20D4 anticlockwiseArrowAbovecmb COMBINING ANTICLOCKWISE ARROW ABOVE 7 | 20D5 clockwiseArrowAbovecmb COMBINING CLOCKWISE ARROW ABOVE 8 | 20D6 leftArrowAbovecmb COMBINING LEFT ARROW ABOVE 9 | 20D7 rightArrowAbovecmb COMBINING RIGHT ARROW ABOVE 10 | 20D8 ringOverlaycmb COMBINING RING OVERLAY 11 | 20D9 clockwiseRingOverlaycmb COMBINING CLOCKWISE RING OVERLAY 12 | 20DA anticlockwiseRingOverlaycmb COMBINING ANTICLOCKWISE RING OVERLAY 13 | 20DB threeDotsAbovecmb COMBINING THREE DOTS ABOVE 14 | 20DC fourDotsAbovecmb COMBINING FOUR DOTS ABOVE 15 | 20DD enclosingCirclecmb COMBINING ENCLOSING CIRCLE 16 | 20DE enclosingSquarecmb COMBINING ENCLOSING SQUARE 17 | 20DF enclosingDiamondcmb COMBINING ENCLOSING DIAMOND 18 | 20E0 enclosingCircleBackslashcmb COMBINING ENCLOSING CIRCLE BACKSLASH 19 | 20E1 leftRightArrowAbovecmb COMBINING LEFT RIGHT ARROW ABOVE 20 | 20E2 enclosingScreencmb COMBINING ENCLOSING SCREEN 21 | 20E3 enclosingKeycapcmb COMBINING ENCLOSING KEYCAP 22 | 20E4 enclosingUpwardPointingTrianglecmb COMBINING ENCLOSING UPWARD POINTING TRIANGLE 23 | 20E5 reverseSolidusOverlaycmb COMBINING REVERSE SOLIDUS OVERLAY 24 | 20E6 doubleVerticalOverlaystrokecmb COMBINING DOUBLE VERTICAL STROKE OVERLAY 25 | 20E7 annuitySymbolcmb COMBINING ANNUITY SYMBOL 26 | 20E8 tripleUnderdotcmb COMBINING TRIPLE UNDERDOT 27 | 20E9 wideBridgeAbovecmb COMBINING WIDE BRIDGE ABOVE 28 | 20EA leftwardsArrowOverlaycmb COMBINING LEFTWARDS ARROW OVERLAY 29 | 20EB longDoubleSolidusOverlaycmb COMBINING LONG DOUBLE SOLIDUS OVERLAY 30 | 20EC rightwardsHarpoonBDownwardsbarcmb COMBINING RIGHTWARDS HARPOON WITH BARB DOWNWARDS 31 | 20ED leftwardsHarpoonBDownwardsbarcmb COMBINING LEFTWARDS HARPOON WITH BARB DOWNWARDS 32 | 20EE leftArrowBelowcmb COMBINING LEFT ARROW BELOW 33 | 20EF rightArrowBelowcmb COMBINING RIGHT ARROW BELOW 34 | 20F0 asteriskAbovecmb COMBINING ASTERISK ABOVE -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/02400-0243F control_pictures.txt: -------------------------------------------------------------------------------- 1 | # Control Pictures 02400 - 0243F 2 | 2400 cntr:null SYMBOL FOR NULL 3 | 2401 cntr:startofheading SYMBOL FOR START OF HEADING 4 | 2402 cntr:startoftext SYMBOL FOR START OF TEXT 5 | 2403 cntr:endoftext SYMBOL FOR END OF TEXT 6 | 2404 cntr:endoftransmission SYMBOL FOR END OF TRANSMISSION 7 | 2405 cntr:enquiry SYMBOL FOR ENQUIRY 8 | 2406 cntr:acknowledge SYMBOL FOR ACKNOWLEDGE 9 | 2407 cntr:bell SYMBOL FOR BELL 10 | 2408 cntr:backspace SYMBOL FOR BACKSPACE 11 | 2409 cntr:horizontaltab SYMBOL FOR HORIZONTAL TABULATION 12 | 240A cntr:linefeed SYMBOL FOR LINE FEED 13 | 240B cntr:verticaltab SYMBOL FOR VERTICAL TABULATION 14 | 240C cntr:formfeed SYMBOL FOR FORM FEED 15 | 240D cntr:carriagereturn SYMBOL FOR CARRIAGE RETURN 16 | 240E cntr:shiftout SYMBOL FOR SHIFT OUT 17 | 240F cntr:shiftin SYMBOL FOR SHIFT IN 18 | 2410 cntr:datalinkescape SYMBOL FOR DATA LINK ESCAPE 19 | 2411 cntr:devicecontrolone SYMBOL FOR DEVICE CONTROL ONE 20 | 2412 cntr:devicecontroltwo SYMBOL FOR DEVICE CONTROL TWO 21 | 2413 cntr:devicecontrolthree SYMBOL FOR DEVICE CONTROL THREE 22 | 2414 cntr:devicecontrolfour SYMBOL FOR DEVICE CONTROL FOUR 23 | 2415 cntr:negativeacknowledge SYMBOL FOR NEGATIVE ACKNOWLEDGE 24 | 2416 cntr:synchronousidle SYMBOL FOR SYNCHRONOUS IDLE 25 | 2417 cntr:endoftransmissionblock SYMBOL FOR END OF TRANSMISSION BLOCK 26 | 2418 cntr:cancel SYMBOL FOR CANCEL 27 | 2419 cntr:endofmedium SYMBOL FOR END OF MEDIUM 28 | 241A cntr:substitute SYMBOL FOR SUBSTITUTE 29 | 241B cntr:escape SYMBOL FOR ESCAPE 30 | 241C cntr:fileseparator SYMBOL FOR FILE SEPARATOR 31 | 241D cntr:groupseparator SYMBOL FOR GROUP SEPARATOR 32 | 241E cntr:recordseparator SYMBOL FOR RECORD SEPARATOR 33 | 241F cntr:unitseparator SYMBOL FOR UNIT SEPARATOR 34 | 2420 cntr:space SYMBOL FOR SPACE 35 | 2421 cntr:delete SYMBOL FOR DELETE 36 | 2422 cntr:blank BLANK SYMBOL 37 | 2423 cntr:openbox OPEN BOX 38 | 2424 cntr:newline SYMBOL FOR NEWLINE 39 | 2425 cntr:deleteformtwo SYMBOL FOR DELETE FORM TWO 40 | 2426 cntr:substituteformtwo SYMBOL FOR SUBSTITUTE FORM TWO 41 | 2427 cntr:deletesquarecheckerboardform SYMBOL FOR DELETE SQUARE CHECKER BOARD FORM 42 | 2428 cntr:deleterectangularcheckerboardform SYMBOL FOR DELETE RECTANGULAR CHECKER BOARD FORM 43 | 2429 cntr:deletemediumshadeform SYMBOL FOR DELETE MEDIUM SHADE FORM -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/0FE30-0FE4F cjk_compatibility_forms.txt: -------------------------------------------------------------------------------- 1 | # CJK Compatibility Forms 0FE30 - 0FE4F 2 | FE30 twodotleadervertical PRESENTATION FORM FOR VERTICAL TWO DOT LEADER 3 | FE31 emdashvertical PRESENTATION FORM FOR VERTICAL EM DASH 4 | FE32 endashvertical PRESENTATION FORM FOR VERTICAL EN DASH 5 | FE33 underscorevertical PRESENTATION FORM FOR VERTICAL LOW LINE 6 | FE34 underscorewavyvertical PRESENTATION FORM FOR VERTICAL WAVY LOW LINE 7 | FE35 parenleftvertical PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS 8 | FE36 parenrightvertical PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS 9 | FE37 braceleftvertical PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET 10 | FE38 bracerightvertical PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET 11 | FE39 tortoiseshellbracketleftvertical PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET 12 | FE3A tortoiseshellbracketrightvertical PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET 13 | FE3B blacklenticularbracketleftvertical PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET 14 | FE3C blacklenticularbracketrightvertical PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET 15 | FE3D dblanglebracketleftvertical PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET 16 | FE3E dblanglebracketrightvertical PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET 17 | FE3F anglebracketleftvertical PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET 18 | FE40 anglebracketrightvertical PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET 19 | FE41 cornerbracketleftvertical PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET 20 | FE42 cornerbracketrightvertical PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET 21 | FE43 whitecornerbracketleftvertical PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET 22 | FE44 whitecornerbracketrightvertical PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET 23 | FE45 sesamedot SESAME DOT 24 | FE46 whitesesamedot WHITE SESAME DOT 25 | FE47 squarebracketleftvertical PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET 26 | FE48 squarebracketrightvertical PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET 27 | FE49 overlinedashed DASHED OVERLINE 28 | FE4A overlinecenterline CENTRELINE OVERLINE 29 | FE4B overlinewavy WAVY OVERLINE 30 | FE4C overlinedblwavy DOUBLE WAVY OVERLINE 31 | FE4D underscoredashed DASHED LOW LINE 32 | FE4E underscorecenterline CENTRELINE LOW LINE 33 | FE4F underscorewavy WAVY LOW LINE -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/helper_digit_names.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | 4 | self.replace("JANUARY", "january") 5 | self.replace("FEBRUARY", "february") 6 | self.replace("MARCH", "march") 7 | self.replace("APRIL", "april") 8 | self.replace("MAY", "may") 9 | self.replace("JUNE", "june") 10 | self.replace("JULY", "july") 11 | self.replace("AUGUST", "august") 12 | self.replace("SEPTEMBER", "september") 13 | self.replace("OCTOBER", "october") 14 | self.replace("NOVEMBER", "november") 15 | self.replace("DECEMBER", "december") 16 | 17 | self.replace("HUNDRED", "hundred") 18 | self.replace("THOUSAND", "thousand") 19 | self.replace("THIRTY SIX", "thirtysix") 20 | self.replace("THIRTY SEVEN", "thirtyseven") 21 | self.replace("THIRTY EIGHT", "thirtyeight") 22 | self.replace("THIRTY NINE", "thirtynine") 23 | self.replace("FORTY ONE", "fortyone") 24 | self.replace("FORTY TWO", "fortytwo") 25 | self.replace("FORTY THREE", "fortythree") 26 | self.replace("FORTY FOUR", "fortyfour") 27 | self.replace("FORTY FIVE", "fortyfive") 28 | self.replace("FORTY SIX", "fortysix") 29 | self.replace("FORTY SEVEN", "fortyseven") 30 | self.replace("FORTY EIGHT", "fortyeight") 31 | self.replace("FORTY NINE", "fortynine") 32 | 33 | self.replace("FOURTEEN", "fourteen") 34 | self.replace("SIXTEEN", "sixteen") 35 | self.replace("SEVENTEEN", "seventeen") 36 | self.replace("EIGHTEEN", "eighteen") 37 | self.replace("NINETEEN", "nineteen") 38 | 39 | self.replace('ZERO', 'zero') 40 | self.replace('ONE', 'one') 41 | self.replace('TWO', 'two') 42 | self.replace('THREE', 'three') 43 | self.replace('FOUR', 'four') 44 | self.replace('FIVE', 'five') 45 | self.replace('SIX', 'six') 46 | self.replace('SEVEN', 'seven') 47 | self.replace('EIGHT', 'eight') 48 | self.replace('NINE', 'nine') 49 | self.replace("TEN", "ten") 50 | self.replace("ELEVEN", "eleven") 51 | self.replace("TWELVE", "twelve") 52 | self.replace("THIRTEEN", "thirteen") 53 | self.replace("FIFTEEN", "fifteen") 54 | self.replace("TWENTY", "twenty") 55 | self.replace("THIRTY", "thirty") 56 | self.replace("FORTY", "forty") 57 | self.replace("FIFTY", "fifty") 58 | self.replace("SIXTY", "sixty") 59 | 60 | if __name__ == "__main__": 61 | from glyphNameFormatter.exporters import printRange 62 | printRange("Helper Digit Names") 63 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/latin_1_supplement.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.edit("LATIN") 4 | 5 | self.edit("NO-BREAK SPACE", "nbspace") 6 | 7 | self.replace("EXCLAMATION MARK", "exclam") 8 | self.replace("QUESTION MARK", "question") 9 | if self.has("INVERTED"): 10 | if self.replace("INVERTED"): 11 | self.suffix("down") 12 | 13 | self.replace("CENT SIGN", "cent") 14 | self.replace("POUND SIGN", "sterling") 15 | self.replace("CURRENCY SIGN", "currency") 16 | self.replace("YEN SIGN", "yen") 17 | self.replace("BROKEN BAR", "brokenbar") 18 | self.replace("SECTION SIGN", "section") 19 | self.replace("COPYRIGHT SIGN", "copyright") 20 | self.replace("FEMININE ORDINAL INDICATOR", "ordfeminine") 21 | self.replace("MASCULINE ORDINAL INDICATOR", "ordmasculine") 22 | self.replace("NOT SIGN", "logicalnot") 23 | self.replace("SOFT HYPHEN", "hyphensoft") 24 | self.replace("REGISTERED SIGN", "registered") 25 | self.replace("DEGREE SIGN", "degree") 26 | self.replace("PLUS-MINUS SIGN", "plusminus") 27 | self.replace("SUPERSCRIPT ONE", "one.superior") 28 | self.replace("SUPERSCRIPT TWO", "two.superior") 29 | self.replace("SUPERSCRIPT THREE", "three.superior") 30 | self.replace("MICRO SIGN", "mu.math") 31 | self.replace("PILCROW SIGN", "paragraph") 32 | self.replace("MIDDLE DOT", 'periodcentered') 33 | 34 | self.edit("ACUTE ACCENT", "acute") 35 | self.edit("CIRCUMFLEX ACCENT", "circumflex") 36 | self.edit("GRAVE ACCENT", "grave") 37 | 38 | self.edit("LEFT-POINTING DOUBLE ANGLE QUOTATION MARK", "guillemet", "left") # or guillemot ? 39 | self.edit("RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK", "guillemet", "right") # or guillemot ? 40 | 41 | self.replace("VULGAR FRACTION ONE QUARTER", "onequarter") 42 | self.replace("VULGAR FRACTION ONE HALF", "onehalf") 43 | self.replace("VULGAR FRACTION THREE QUARTERS", "threequarters") 44 | 45 | self.replace("MULTIPLICATION SIGN", "multiply") 46 | self.replace("DIVISION SIGN", "divide") 47 | 48 | self.replace("CAPITAL LETTER AE", "AE") 49 | self.replace("WITH STROKE", "slash") 50 | self.replace("SMALL LETTER SHARP S", "germandbls") 51 | 52 | self.processAs("Helper Diacritics") 53 | 54 | self.handleCase() 55 | self.compress() 56 | 57 | 58 | if __name__ == "__main__": 59 | from glyphNameFormatter.exporters import printRange 60 | 61 | printRange("Latin-1 Supplement") 62 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/test/testAGDcoverage.py: -------------------------------------------------------------------------------- 1 | from __future__ import print_function 2 | from glyphNameFormatter.unicodeRangeNames import getRangeName, getAllRangeNames, rangeNameToModuleName 3 | 4 | from glyphNameFormatter.data import name2unicode_AGD 5 | import importlib 6 | 7 | 8 | # find which unicode ranges are needed to cover the AGD names 9 | # so we can prioritize the support 10 | 11 | def testAGDCoverage(): 12 | wantRanges = [] 13 | glyphCount = {} 14 | for name in name2unicode_AGD: 15 | uniNumber = name2unicode_AGD[name] 16 | thisRange = getRangeName(uniNumber) 17 | if thisRange == "Private Use Area": 18 | continue 19 | if thisRange not in glyphCount: 20 | glyphCount[thisRange] = 0 21 | glyphCount[thisRange] += 1 22 | if thisRange is None: 23 | continue 24 | if thisRange not in wantRanges: 25 | wantRanges.append(thisRange) 26 | supported = [] 27 | notSupported = [] 28 | notNeeded = [] 29 | for name in wantRanges: 30 | if name == "Private Use Area": 31 | continue 32 | moduleName = rangeNameToModuleName(name) 33 | try: 34 | module = importlib.import_module('glyphNameFormatter.rangeProcessors.%s' % moduleName) 35 | supported.append(name) 36 | except ImportError: 37 | notSupported.append(name) 38 | for name in getAllRangeNames(): 39 | if name not in supported and name not in notSupported: 40 | notNeeded.append(name) 41 | supported.sort() 42 | notSupported.sort() 43 | notNeeded.sort() 44 | supportedTotal = 0 45 | notSupportedTotal = 0 46 | print("Available range processors for AGD:") 47 | for n in supported: 48 | print("\t%8d\t%s" % (glyphCount[n], n)) 49 | supportedTotal += glyphCount[n] 50 | print("\nMissing range processors for AGD:") 51 | for n in notSupported: 52 | print("\t%8d\t%s" % (glyphCount[n], n)) 53 | notSupportedTotal += glyphCount[n] 54 | print("Supported total", supportedTotal+notSupportedTotal) 55 | print("AGD supported total", supportedTotal) 56 | print("AGD total", len(name2unicode_AGD)) 57 | print("Coverage complete: %3.1f%%" % (100.0*supportedTotal/len(name2unicode_AGD))) 58 | 59 | print("\nRange processors not needed for AGD:") 60 | for n in notNeeded: 61 | print("\t", n) 62 | 63 | 64 | if __name__ == "__main__": 65 | testAGDCoverage() 66 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/1F000-1F02F mahjong_tiles.txt: -------------------------------------------------------------------------------- 1 | # Mahjong Tiles 1F000 - 1F02F 2 | 1F000 eastWindMahjong MAHJONG TILE EAST WIND 3 | 1F001 southWindMahjong MAHJONG TILE SOUTH WIND 4 | 1F002 westWindMahjong MAHJONG TILE WEST WIND 5 | 1F003 northWindMahjong MAHJONG TILE NORTH WIND 6 | 1F004 redDragonMahjong MAHJONG TILE RED DRAGON 7 | 1F005 greenDragonMahjong MAHJONG TILE GREEN DRAGON 8 | 1F006 whiteDragonMahjong MAHJONG TILE WHITE DRAGON 9 | 1F007 oneOfCharactersMahjong MAHJONG TILE ONE OF CHARACTERS 10 | 1F008 twoOfCharactersMahjong MAHJONG TILE TWO OF CHARACTERS 11 | 1F009 threeOfCharactersMahjong MAHJONG TILE THREE OF CHARACTERS 12 | 1F00A fourOfCharactersMahjong MAHJONG TILE FOUR OF CHARACTERS 13 | 1F00B fiveOfCharactersMahjong MAHJONG TILE FIVE OF CHARACTERS 14 | 1F00C sixOfCharactersMahjong MAHJONG TILE SIX OF CHARACTERS 15 | 1F00D sevenOfCharactersMahjong MAHJONG TILE SEVEN OF CHARACTERS 16 | 1F00E eightOfCharactersMahjong MAHJONG TILE EIGHT OF CHARACTERS 17 | 1F00F nineOfCharactersMahjong MAHJONG TILE NINE OF CHARACTERS 18 | 1F010 oneOfBamboosMahjong MAHJONG TILE ONE OF BAMBOOS 19 | 1F011 twoOfBamboosMahjong MAHJONG TILE TWO OF BAMBOOS 20 | 1F012 threeOfBamboosMahjong MAHJONG TILE THREE OF BAMBOOS 21 | 1F013 fourOfBamboosMahjong MAHJONG TILE FOUR OF BAMBOOS 22 | 1F014 fiveOfBamboosMahjong MAHJONG TILE FIVE OF BAMBOOS 23 | 1F015 sixOfBamboosMahjong MAHJONG TILE SIX OF BAMBOOS 24 | 1F016 sevenOfBamboosMahjong MAHJONG TILE SEVEN OF BAMBOOS 25 | 1F017 eightOfBamboosMahjong MAHJONG TILE EIGHT OF BAMBOOS 26 | 1F018 nineOfBamboosMahjong MAHJONG TILE NINE OF BAMBOOS 27 | 1F019 oneOfCirclesMahjong MAHJONG TILE ONE OF CIRCLES 28 | 1F01A twoOfCirclesMahjong MAHJONG TILE TWO OF CIRCLES 29 | 1F01B threeOfCirclesMahjong MAHJONG TILE THREE OF CIRCLES 30 | 1F01C fourOfCirclesMahjong MAHJONG TILE FOUR OF CIRCLES 31 | 1F01D fiveOfCirclesMahjong MAHJONG TILE FIVE OF CIRCLES 32 | 1F01E sixOfCirclesMahjong MAHJONG TILE SIX OF CIRCLES 33 | 1F01F sevenOfCirclesMahjong MAHJONG TILE SEVEN OF CIRCLES 34 | 1F020 eightOfCirclesMahjong MAHJONG TILE EIGHT OF CIRCLES 35 | 1F021 nineOfCirclesMahjong MAHJONG TILE NINE OF CIRCLES 36 | 1F022 plumMahjong MAHJONG TILE PLUM 37 | 1F023 orchidMahjong MAHJONG TILE ORCHID 38 | 1F024 bambooMahjong MAHJONG TILE BAMBOO 39 | 1F025 chrysanthemumMahjong MAHJONG TILE CHRYSANTHEMUM 40 | 1F026 springMahjong MAHJONG TILE SPRING 41 | 1F027 summerMahjong MAHJONG TILE SUMMER 42 | 1F028 autumnMahjong MAHJONG TILE AUTUMN 43 | 1F029 winterMahjong MAHJONG TILE WINTER 44 | 1F02A jokerMahjong MAHJONG TILE JOKER 45 | 1F02B backMahjong MAHJONG TILE BACK -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/01C90-01CBF georgian_extended.txt: -------------------------------------------------------------------------------- 1 | # Georgian Extended 01C90 - 01CBF 2 | 1C90 AnGeor GEORGIAN MTAVRULI CAPITAL LETTER AN 3 | 1C91 BanGeor GEORGIAN MTAVRULI CAPITAL LETTER BAN 4 | 1C92 GanGeor GEORGIAN MTAVRULI CAPITAL LETTER GAN 5 | 1C93 DonGeor GEORGIAN MTAVRULI CAPITAL LETTER DON 6 | 1C94 EnGeor GEORGIAN MTAVRULI CAPITAL LETTER EN 7 | 1C95 VinGeor GEORGIAN MTAVRULI CAPITAL LETTER VIN 8 | 1C96 ZenGeor GEORGIAN MTAVRULI CAPITAL LETTER ZEN 9 | 1C97 TanGeor GEORGIAN MTAVRULI CAPITAL LETTER TAN 10 | 1C98 InGeor GEORGIAN MTAVRULI CAPITAL LETTER IN 11 | 1C99 KanGeor GEORGIAN MTAVRULI CAPITAL LETTER KAN 12 | 1C9A LasGeor GEORGIAN MTAVRULI CAPITAL LETTER LAS 13 | 1C9B ManGeor GEORGIAN MTAVRULI CAPITAL LETTER MAN 14 | 1C9C NarGeor GEORGIAN MTAVRULI CAPITAL LETTER NAR 15 | 1C9D OnGeor GEORGIAN MTAVRULI CAPITAL LETTER ON 16 | 1C9E ParGeor GEORGIAN MTAVRULI CAPITAL LETTER PAR 17 | 1C9F ZharGeor GEORGIAN MTAVRULI CAPITAL LETTER ZHAR 18 | 1CA0 RaeGeor GEORGIAN MTAVRULI CAPITAL LETTER RAE 19 | 1CA1 SanGeor GEORGIAN MTAVRULI CAPITAL LETTER SAN 20 | 1CA2 TarGeor GEORGIAN MTAVRULI CAPITAL LETTER TAR 21 | 1CA3 UnGeor GEORGIAN MTAVRULI CAPITAL LETTER UN 22 | 1CA4 PharGeor GEORGIAN MTAVRULI CAPITAL LETTER PHAR 23 | 1CA5 KharGeor GEORGIAN MTAVRULI CAPITAL LETTER KHAR 24 | 1CA6 GhanGeor GEORGIAN MTAVRULI CAPITAL LETTER GHAN 25 | 1CA7 QarGeor GEORGIAN MTAVRULI CAPITAL LETTER QAR 26 | 1CA8 ShinGeor GEORGIAN MTAVRULI CAPITAL LETTER SHIN 27 | 1CA9 ChinGeor GEORGIAN MTAVRULI CAPITAL LETTER CHIN 28 | 1CAA CanGeor GEORGIAN MTAVRULI CAPITAL LETTER CAN 29 | 1CAB JilGeor GEORGIAN MTAVRULI CAPITAL LETTER JIL 30 | 1CAC CilGeor GEORGIAN MTAVRULI CAPITAL LETTER CIL 31 | 1CAD CharGeor GEORGIAN MTAVRULI CAPITAL LETTER CHAR 32 | 1CAE XanGeor GEORGIAN MTAVRULI CAPITAL LETTER XAN 33 | 1CAF JhanGeor GEORGIAN MTAVRULI CAPITAL LETTER JHAN 34 | 1CB0 HaeGeor GEORGIAN MTAVRULI CAPITAL LETTER HAE 35 | 1CB1 HeGeor GEORGIAN MTAVRULI CAPITAL LETTER HE 36 | 1CB2 HieGeor GEORGIAN MTAVRULI CAPITAL LETTER HIE 37 | 1CB3 WeGeor GEORGIAN MTAVRULI CAPITAL LETTER WE 38 | 1CB4 HarGeor GEORGIAN MTAVRULI CAPITAL LETTER HAR 39 | 1CB5 HoeGeor GEORGIAN MTAVRULI CAPITAL LETTER HOE 40 | 1CB6 FiGeor GEORGIAN MTAVRULI CAPITAL LETTER FI 41 | 1CB7 YnGeor GEORGIAN MTAVRULI CAPITAL LETTER YN 42 | 1CB8 ElifiGeor GEORGIAN MTAVRULI CAPITAL LETTER ELIFI 43 | 1CB9 TurnedganGeor GEORGIAN MTAVRULI CAPITAL LETTER TURNED GAN 44 | 1CBA AinGeor GEORGIAN MTAVRULI CAPITAL LETTER AIN 45 | 1CBD AenGeor GEORGIAN MTAVRULI CAPITAL LETTER AEN 46 | 1CBE HardsignGeor GEORGIAN MTAVRULI CAPITAL LETTER HARD SIGN 47 | 1CBF LabialsignGeor GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/00500-0052F cyrillic_supplement.txt: -------------------------------------------------------------------------------- 1 | # Cyrillic Supplement 00500 - 0052F 2 | 0500 Dekomicyr CYRILLIC CAPITAL LETTER KOMI DE 3 | 0501 dekomicyr CYRILLIC SMALL LETTER KOMI DE 4 | 0502 Djekomicyr CYRILLIC CAPITAL LETTER KOMI DJE 5 | 0503 djekomicyr CYRILLIC SMALL LETTER KOMI DJE 6 | 0504 Zjekomicyr CYRILLIC CAPITAL LETTER KOMI ZJE 7 | 0505 zjekomicyr CYRILLIC SMALL LETTER KOMI ZJE 8 | 0506 Dzjekomicyr CYRILLIC CAPITAL LETTER KOMI DZJE 9 | 0507 dzjekomicyr CYRILLIC SMALL LETTER KOMI DZJE 10 | 0508 Ljekomicyr CYRILLIC CAPITAL LETTER KOMI LJE 11 | 0509 ljekomicyr CYRILLIC SMALL LETTER KOMI LJE 12 | 050A Njekomicyr CYRILLIC CAPITAL LETTER KOMI NJE 13 | 050B njekomicyr CYRILLIC SMALL LETTER KOMI NJE 14 | 050C Sjekomicyr CYRILLIC CAPITAL LETTER KOMI SJE 15 | 050D sjekomicyr CYRILLIC SMALL LETTER KOMI SJE 16 | 050E Tjekomicyr CYRILLIC CAPITAL LETTER KOMI TJE 17 | 050F tjekomicyr CYRILLIC SMALL LETTER KOMI TJE 18 | 0510 Reversedzecyr CYRILLIC CAPITAL LETTER REVERSED ZE 19 | 0511 reversedzecyr CYRILLIC SMALL LETTER REVERSED ZE 20 | 0512 Elhookcyr CYRILLIC CAPITAL LETTER EL WITH HOOK 21 | 0513 elhookcyr CYRILLIC SMALL LETTER EL WITH HOOK 22 | 0514 Lhacyr CYRILLIC CAPITAL LETTER LHA 23 | 0515 lhacyr CYRILLIC SMALL LETTER LHA 24 | 0516 Rhacyr CYRILLIC CAPITAL LETTER RHA 25 | 0517 rhacyr CYRILLIC SMALL LETTER RHA 26 | 0518 Yaecyr CYRILLIC CAPITAL LETTER YAE 27 | 0519 yaecyr CYRILLIC SMALL LETTER YAE 28 | 051A Qacyr CYRILLIC CAPITAL LETTER QA 29 | 051B qacyr CYRILLIC SMALL LETTER QA 30 | 051C Wecyr CYRILLIC CAPITAL LETTER WE 31 | 051D wecyr CYRILLIC SMALL LETTER WE 32 | 051E Kaaleutcyr CYRILLIC CAPITAL LETTER ALEUT KA 33 | 051F kaaleutcyr CYRILLIC SMALL LETTER ALEUT KA 34 | 0520 Elmiddlehookcyr CYRILLIC CAPITAL LETTER EL WITH MIDDLE HOOK 35 | 0521 elmiddlehookcyr CYRILLIC SMALL LETTER EL WITH MIDDLE HOOK 36 | 0522 Enmiddlehookcyr CYRILLIC CAPITAL LETTER EN WITH MIDDLE HOOK 37 | 0523 enmiddlehookcyr CYRILLIC SMALL LETTER EN WITH MIDDLE HOOK 38 | 0524 Petailcyr CYRILLIC CAPITAL LETTER PE WITH DESCENDER 39 | 0525 petailcyr CYRILLIC SMALL LETTER PE WITH DESCENDER 40 | 0526 Shhatailcyr CYRILLIC CAPITAL LETTER SHHA WITH DESCENDER 41 | 0527 shhatailcyr CYRILLIC SMALL LETTER SHHA WITH DESCENDER 42 | 0528 Enhookleftcyr CYRILLIC CAPITAL LETTER EN WITH LEFT HOOK 43 | 0529 enhookleftcyr CYRILLIC SMALL LETTER EN WITH LEFT HOOK 44 | 052A Dzzhecyr CYRILLIC CAPITAL LETTER DZZHE 45 | 052B dzzhecyr CYRILLIC SMALL LETTER DZZHE 46 | 052C Dchecyr CYRILLIC CAPITAL LETTER DCHE 47 | 052D dchecyr CYRILLIC SMALL LETTER DCHE 48 | 052E Eltailcyr CYRILLIC CAPITAL LETTER EL WITH DESCENDER 49 | 052F eltailcyr CYRILLIC SMALL LETTER EL WITH DESCENDER -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/00B80-00BFF tamil.txt: -------------------------------------------------------------------------------- 1 | # Tamil 00B80 - 00BFF 2 | 0B82 taml:anusvara TAMIL SIGN ANUSVARA 3 | 0B83 taml:visarga TAMIL SIGN VISARGA 4 | 0B85 taml:a TAMIL LETTER A 5 | 0B86 taml:aa TAMIL LETTER AA 6 | 0B87 taml:i TAMIL LETTER I 7 | 0B88 taml:ii TAMIL LETTER II 8 | 0B89 taml:u TAMIL LETTER U 9 | 0B8A taml:uu TAMIL LETTER UU 10 | 0B8E taml:e TAMIL LETTER E 11 | 0B8F taml:ee TAMIL LETTER EE 12 | 0B90 taml:ai TAMIL LETTER AI 13 | 0B92 taml:o TAMIL LETTER O 14 | 0B93 taml:oo TAMIL LETTER OO 15 | 0B94 taml:au TAMIL LETTER AU 16 | 0B95 taml:ka TAMIL LETTER KA 17 | 0B99 taml:nga TAMIL LETTER NGA 18 | 0B9A taml:ca TAMIL LETTER CA 19 | 0B9C taml:ja TAMIL LETTER JA 20 | 0B9E taml:nya TAMIL LETTER NYA 21 | 0B9F taml:tta TAMIL LETTER TTA 22 | 0BA3 taml:nna TAMIL LETTER NNA 23 | 0BA4 taml:ta TAMIL LETTER TA 24 | 0BA8 taml:na TAMIL LETTER NA 25 | 0BA9 taml:nnna TAMIL LETTER NNNA 26 | 0BAA taml:pa TAMIL LETTER PA 27 | 0BAE taml:ma TAMIL LETTER MA 28 | 0BAF taml:ya TAMIL LETTER YA 29 | 0BB0 taml:ra TAMIL LETTER RA 30 | 0BB1 taml:rra TAMIL LETTER RRA 31 | 0BB2 taml:la TAMIL LETTER LA 32 | 0BB3 taml:lla TAMIL LETTER LLA 33 | 0BB4 taml:llla TAMIL LETTER LLLA 34 | 0BB5 taml:va TAMIL LETTER VA 35 | 0BB6 taml:sha TAMIL LETTER SHA 36 | 0BB7 taml:ssa TAMIL LETTER SSA 37 | 0BB8 taml:sa TAMIL LETTER SA 38 | 0BB9 taml:ha TAMIL LETTER HA 39 | 0BBE taml:aasign TAMIL VOWEL SIGN AA 40 | 0BBF taml:isign TAMIL VOWEL SIGN I 41 | 0BC0 taml:iisign TAMIL VOWEL SIGN II 42 | 0BC1 taml:usign TAMIL VOWEL SIGN U 43 | 0BC2 taml:uusign TAMIL VOWEL SIGN UU 44 | 0BC6 taml:esign TAMIL VOWEL SIGN E 45 | 0BC7 taml:eesign TAMIL VOWEL SIGN EE 46 | 0BC8 taml:aisign TAMIL VOWEL SIGN AI 47 | 0BCA taml:osign TAMIL VOWEL SIGN O 48 | 0BCB taml:oosign TAMIL VOWEL SIGN OO 49 | 0BCC taml:ausign TAMIL VOWEL SIGN AU 50 | 0BCD taml:virama TAMIL SIGN VIRAMA 51 | 0BD0 taml:om TAMIL OM 52 | 0BD7 taml:aulengthmark TAMIL AU LENGTH MARK 53 | 0BE6 taml:zero TAMIL DIGIT ZERO 54 | 0BE7 taml:one TAMIL DIGIT ONE 55 | 0BE8 taml:two TAMIL DIGIT TWO 56 | 0BE9 taml:three TAMIL DIGIT THREE 57 | 0BEA taml:four TAMIL DIGIT FOUR 58 | 0BEB taml:five TAMIL DIGIT FIVE 59 | 0BEC taml:six TAMIL DIGIT SIX 60 | 0BED taml:seven TAMIL DIGIT SEVEN 61 | 0BEE taml:eight TAMIL DIGIT EIGHT 62 | 0BEF taml:nine TAMIL DIGIT NINE 63 | 0BF0 taml:ten TAMIL NUMBER TEN 64 | 0BF1 taml:onehundred TAMIL NUMBER ONE HUNDRED 65 | 0BF2 taml:onethousand TAMIL NUMBER ONE THOUSAND 66 | 0BF3 taml:daysign TAMIL DAY SIGN 67 | 0BF4 taml:monthsign TAMIL MONTH SIGN 68 | 0BF5 taml:yearsign TAMIL YEAR SIGN 69 | 0BF6 taml:debitsign TAMIL DEBIT SIGN 70 | 0BF7 taml:creditsign TAMIL CREDIT SIGN 71 | 0BF8 taml:asabovesign TAMIL AS ABOVE SIGN 72 | 0BF9 taml:rupee TAMIL RUPEE SIGN 73 | 0BFA taml:sign TAMIL NUMBER SIGN -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/027C0-027EF miscellaneous_mathematical_symbols-a.txt: -------------------------------------------------------------------------------- 1 | # Miscellaneous Mathematical Symbols-A 027C0 - 027EF 2 | 27C0 threedimensionalangle THREE DIMENSIONAL ANGLE 3 | 27C1 tricontainingtriwhiteanglesmall WHITE TRIANGLE CONTAINING SMALL WHITE TRIANGLE 4 | 27C2 perpendicular PERPENDICULAR 5 | 27C3 opensubset OPEN SUBSET 6 | 27C4 opensuperset OPEN SUPERSET 7 | 27C5 bagdelimitersshapeleft LEFT S-SHAPED BAG DELIMITER 8 | 27C6 bagdelimitersshaperight RIGHT S-SHAPED BAG DELIMITER 9 | 27C7 ordotinside OR WITH DOT INSIDE 10 | 27C8 solidussubsetreversepreceding REVERSE SOLIDUS PRECEDING SUBSET 11 | 27C9 solidussupersetpreceding SUPERSET PRECEDING SOLIDUS 12 | 27CA verticalbarhorizontalstroke VERTICAL BAR WITH HORIZONTAL STROKE 13 | 27CB risingdiagonal MATHEMATICAL RISING DIAGONAL 14 | 27CC longdivision LONG DIVISION 15 | 27CD fallingdiagonal MATHEMATICAL FALLING DIAGONAL 16 | 27CE dlogicalsquare SQUARED LOGICAL AND 17 | 27CF dlogicalorsquare SQUARED LOGICAL OR 18 | 27D0 centreddotwhitediamond WHITE DIAMOND WITH CENTRED DOT 19 | 27D1 andwithdot AND WITH DOT 20 | 27D2 elementopeningup ELEMENT OF OPENING UPWARDS 21 | 27D3 lowercornerdotright LOWER RIGHT CORNER WITH DOT 22 | 27D4 cornerdotupleft UPPER LEFT CORNER WITH DOT 23 | 27D5 outerjoinleft LEFT OUTER JOIN 24 | 27D6 outerjoinright RIGHT OUTER JOIN 25 | 27D7 outerjoinfull FULL OUTER JOIN 26 | 27D8 largetackup LARGE UP TACK 27 | 27D9 largetackdown LARGE DOWN TACK 28 | 27DA turnstileleftrightdbl LEFT AND RIGHT DOUBLE TURNSTILE 29 | 27DB tackleftright LEFT AND RIGHT TACK 30 | 27DC multimapleft LEFT MULTIMAP 31 | 27DD longtackright LONG RIGHT TACK 32 | 27DE longtackleft LONG LEFT TACK 33 | 27DF tackcircleaboveup UP TACK WITH CIRCLE ABOVE 34 | 27E0 lozengedividedbyrulehorizontal LOZENGE DIVIDED BY HORIZONTAL RULE 35 | 27E1 convavediamondwhite WHITE CONCAVE-SIDED DIAMOND 36 | 27E2 tickconvavediamondleftwhite WHITE CONCAVE-SIDED DIAMOND WITH LEFTWARDS TICK 37 | 27E3 tickconvavediamondrightwhite WHITE CONCAVE-SIDED DIAMOND WITH RIGHTWARDS TICK 38 | 27E4 tickleftwhitesquare WHITE SQUARE WITH LEFTWARDS TICK 39 | 27E5 tickrightwhitesquare WHITE SQUARE WITH RIGHTWARDS TICK 40 | 27E6 bracketwhitesquareleft MATHEMATICAL LEFT WHITE SQUARE BRACKET 41 | 27E7 bracketwhitesquareright MATHEMATICAL RIGHT WHITE SQUARE BRACKET 42 | 27E8 bracketangleleft MATHEMATICAL LEFT ANGLE BRACKET 43 | 27E9 bracketangleright MATHEMATICAL RIGHT ANGLE BRACKET 44 | 27EA bracketangledblleft MATHEMATICAL LEFT DOUBLE ANGLE BRACKET 45 | 27EB bracketangledblright MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET 46 | 27EC bracketshellwhiteleft MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET 47 | 27ED bracketshellwhiteright MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET 48 | 27EE parenflatleft MATHEMATICAL LEFT FLATTENED PARENTHESIS 49 | 27EF parenflatright MATHEMATICAL RIGHT FLATTENED PARENTHESIS -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/01CD0-01CFF vedic_extensions.txt: -------------------------------------------------------------------------------- 1 | # Vedic Extensions 01CD0 - 01CFF 2 | 1CD0 ve:karshanatone VEDIC TONE KARSHANA 3 | 1CD1 ve:sharatone VEDIC TONE SHARA 4 | 1CD2 ve:prenkhatone VEDIC TONE PRENKHA 5 | 1CD3 ve:nihshvasasign VEDIC SIGN NIHSHVASA 6 | 1CD4 ve:yajurmidlinesvaritasign VEDIC SIGN YAJURVEDIC MIDLINE SVARITA 7 | 1CD5 ve:yajuraggravatedindependentsvaritatone VEDIC TONE YAJURVEDIC AGGRAVATED INDEPENDENT SVARITA 8 | 1CD6 ve:yajurindependentsvaritatone VEDIC TONE YAJURVEDIC INDEPENDENT SVARITA 9 | 1CD7 ve:yajurkathakaindependentsvaritatone VEDIC TONE YAJURVEDIC KATHAKA INDEPENDENT SVARITA 10 | 1CD8 ve:belowtonecandra VEDIC TONE CANDRA BELOW 11 | 1CD9 ve:yajurkathakaindependentsvaritaschroedertone VEDIC TONE YAJURVEDIC KATHAKA INDEPENDENT SVARITA SCHROEDER 12 | 1CDA ve:svaritatonedbl VEDIC TONE DOUBLE SVARITA 13 | 1CDB ve:svaritatonetpl VEDIC TONE TRIPLE SVARITA 14 | 1CDC ve:kathakaanudattatone VEDIC TONE KATHAKA ANUDATTA 15 | 1CDD ve:dotbelowtone VEDIC TONE DOT BELOW 16 | 1CDE ve:twodotsbelowtone VEDIC TONE TWO DOTS BELOW 17 | 1CDF ve:threedotsbelowtone VEDIC TONE THREE DOTS BELOW 18 | 1CE0 ve:rigkashmiriindependentsvaritatone VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA 19 | 1CE1 ve:atharvaindependentsvaritatone VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA 20 | 1CE2 ve:visargasvaritasign VEDIC SIGN VISARGA SVARITA 21 | 1CE3 ve:visargaudattasign VEDIC SIGN VISARGA UDATTA 22 | 1CE4 ve:visargaudattasignreversed VEDIC SIGN REVERSED VISARGA UDATTA 23 | 1CE5 ve:visargaanudattasign VEDIC SIGN VISARGA ANUDATTA 24 | 1CE6 ve:visargaanudattasignreversed VEDIC SIGN REVERSED VISARGA ANUDATTA 25 | 1CE7 ve:visargaudattawithtailsign VEDIC SIGN VISARGA UDATTA WITH TAIL 26 | 1CE8 ve:visargaanudattawithtailsign VEDIC SIGN VISARGA ANUDATTA WITH TAIL 27 | 1CE9 ve:anusvaraantargomukhasign VEDIC SIGN ANUSVARA ANTARGOMUKHA 28 | 1CEA ve:anusvarabahirgomukhasign VEDIC SIGN ANUSVARA BAHIRGOMUKHA 29 | 1CEB ve:anusvaravamagomukhasign VEDIC SIGN ANUSVARA VAMAGOMUKHA 30 | 1CEC ve:anusvaravamagomukhawithtailsign VEDIC SIGN ANUSVARA VAMAGOMUKHA WITH TAIL 31 | 1CED ve:tiryaksign VEDIC SIGN TIRYAK 32 | 1CEE ve:hexiformanusvarasignlong VEDIC SIGN HEXIFORM LONG ANUSVARA 33 | 1CEF ve:anusvarasignlong VEDIC SIGN LONG ANUSVARA 34 | 1CF0 ve:rthanganusvarasignlong VEDIC SIGN RTHANG LONG ANUSVARA 35 | 1CF1 ve:anusvaraubhayatomukhasign VEDIC SIGN ANUSVARA UBHAYATO MUKHA 36 | 1CF2 ve:ardhavisargasign VEDIC SIGN ARDHAVISARGA 37 | 1CF3 ve:rotatedardhavisargasign VEDIC SIGN ROTATED ARDHAVISARGA 38 | 1CF4 ve:abovetonecandra VEDIC TONE CANDRA ABOVE 39 | 1CF5 ve:jihvamuliyasign VEDIC SIGN JIHVAMULIYA 40 | 1CF6 ve:upadhmaniyasign VEDIC SIGN UPADHMANIYA 41 | 1CF7 ve:atikramasign VEDIC SIGN ATIKRAMA 42 | 1CF8 ve:ringabovetone VEDIC TONE RING ABOVE 43 | 1CF9 ve:ringabovetonedbl VEDIC TONE DOUBLE RING ABOVE 44 | 1CFA ve:anusvaraantargomukhasigndbl VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/02150-0218F number_forms.txt: -------------------------------------------------------------------------------- 1 | # Number Forms 02150 - 0218F 2 | 2150 oneseventh VULGAR FRACTION ONE SEVENTH 3 | 2151 oneninth VULGAR FRACTION ONE NINTH 4 | 2152 onetenth VULGAR FRACTION ONE TENTH 5 | 2153 onethird VULGAR FRACTION ONE THIRD 6 | 2154 twothirds VULGAR FRACTION TWO THIRDS 7 | 2155 onefifth VULGAR FRACTION ONE FIFTH 8 | 2156 twofifths VULGAR FRACTION TWO FIFTHS 9 | 2157 threefifths VULGAR FRACTION THREE FIFTHS 10 | 2158 fourfifths VULGAR FRACTION FOUR FIFTHS 11 | 2159 onesixth VULGAR FRACTION ONE SIXTH 12 | 215A fivesixths VULGAR FRACTION FIVE SIXTHS 13 | 215B oneeighth VULGAR FRACTION ONE EIGHTH 14 | 215C threeeighths VULGAR FRACTION THREE EIGHTHS 15 | 215D fiveeighths VULGAR FRACTION FIVE EIGHTHS 16 | 215E seveneighths VULGAR FRACTION SEVEN EIGHTHS 17 | 215F onefraction FRACTION NUMERATOR ONE 18 | 2160 one.roman ROMAN NUMERAL ONE 19 | 2161 two.roman ROMAN NUMERAL TWO 20 | 2162 three.roman ROMAN NUMERAL THREE 21 | 2163 four.roman ROMAN NUMERAL FOUR 22 | 2164 five.roman ROMAN NUMERAL FIVE 23 | 2165 six.roman ROMAN NUMERAL SIX 24 | 2166 seven.roman ROMAN NUMERAL SEVEN 25 | 2167 eight.roman ROMAN NUMERAL EIGHT 26 | 2168 nine.roman ROMAN NUMERAL NINE 27 | 2169 ten.roman ROMAN NUMERAL TEN 28 | 216A eleven.roman ROMAN NUMERAL ELEVEN 29 | 216B twelve.roman ROMAN NUMERAL TWELVE 30 | 216C fifty.roman ROMAN NUMERAL FIFTY 31 | 216D onehundred.roman ROMAN NUMERAL ONE HUNDRED 32 | 216E fivehundred.roman ROMAN NUMERAL FIVE HUNDRED 33 | 216F onethousand.roman ROMAN NUMERAL ONE THOUSAND 34 | 2170 one.romansmall SMALL ROMAN NUMERAL ONE 35 | 2171 two.romansmall SMALL ROMAN NUMERAL TWO 36 | 2172 three.romansmall SMALL ROMAN NUMERAL THREE 37 | 2173 four.romansmall SMALL ROMAN NUMERAL FOUR 38 | 2174 five.romansmall SMALL ROMAN NUMERAL FIVE 39 | 2175 six.romansmall SMALL ROMAN NUMERAL SIX 40 | 2176 seven.romansmall SMALL ROMAN NUMERAL SEVEN 41 | 2177 eight.romansmall SMALL ROMAN NUMERAL EIGHT 42 | 2178 nine.romansmall SMALL ROMAN NUMERAL NINE 43 | 2179 ten.romansmall SMALL ROMAN NUMERAL TEN 44 | 217A eleven.romansmall SMALL ROMAN NUMERAL ELEVEN 45 | 217B twelve.romansmall SMALL ROMAN NUMERAL TWELVE 46 | 217C fifty.romansmall SMALL ROMAN NUMERAL FIFTY 47 | 217D onehundred.romansmall SMALL ROMAN NUMERAL ONE HUNDRED 48 | 217E fivehundred.romansmall SMALL ROMAN NUMERAL FIVE HUNDRED 49 | 217F onethousand.romansmall SMALL ROMAN NUMERAL ONE THOUSAND 50 | 2180 onethousandcd.roman ROMAN NUMERAL ONE THOUSAND C D 51 | 2181 fivethousand.roman ROMAN NUMERAL FIVE THOUSAND 52 | 2182 tenthousand.roman ROMAN NUMERAL TEN THOUSAND 53 | 2183 reversedonehundred.roman ROMAN NUMERAL REVERSED ONE HUNDRED 54 | 2184 creversed LATIN SMALL LETTER REVERSED C 55 | 2185 sixlateform.roman ROMAN NUMERAL SIX LATE FORM 56 | 2186 fiftyearlyform.roman ROMAN NUMERAL FIFTY EARLY FORM 57 | 2187 fiftythousand.roman ROMAN NUMERAL FIFTY THOUSAND 58 | 2188 onehundredthousand.roman ROMAN NUMERAL ONE HUNDRED THOUSAND 59 | 2189 zerothirds VULGAR FRACTION ZERO THIRDS 60 | 218A turneddigittwo TURNED DIGIT TWO 61 | 218B turneddigitthree TURNED DIGIT THREE -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/00000-0007F basic_latin.txt: -------------------------------------------------------------------------------- 1 | # Basic Latin 00000 - 0007F 2 | 0020 space SPACE 3 | 0021 exclam EXCLAMATION MARK 4 | 0022 quotedbl QUOTATION MARK 5 | 0023 numbersign NUMBER SIGN 6 | 0024 dollar DOLLAR SIGN 7 | 0025 percent PERCENT SIGN 8 | 0026 ampersand AMPERSAND 9 | 0027 quotesingle APOSTROPHE 10 | 0028 parenleft LEFT PARENTHESIS 11 | 0029 parenright RIGHT PARENTHESIS 12 | 002A asterisk ASTERISK 13 | 002B plus PLUS SIGN 14 | 002C comma COMMA 15 | 002D hyphen HYPHEN-MINUS 16 | 002E period FULL STOP 17 | 002F slash SOLIDUS 18 | 0030 zero DIGIT ZERO 19 | 0031 one DIGIT ONE 20 | 0032 two DIGIT TWO 21 | 0033 three DIGIT THREE 22 | 0034 four DIGIT FOUR 23 | 0035 five DIGIT FIVE 24 | 0036 six DIGIT SIX 25 | 0037 seven DIGIT SEVEN 26 | 0038 eight DIGIT EIGHT 27 | 0039 nine DIGIT NINE 28 | 003A colon COLON 29 | 003B semicolon SEMICOLON 30 | 003C less LESS-THAN SIGN 31 | 003D equal EQUALS SIGN 32 | 003E greater GREATER-THAN SIGN 33 | 003F question QUESTION MARK 34 | 0040 at COMMERCIAL AT 35 | 0041 A LATIN CAPITAL LETTER A 36 | 0042 B LATIN CAPITAL LETTER B 37 | 0043 C LATIN CAPITAL LETTER C 38 | 0044 D LATIN CAPITAL LETTER D 39 | 0045 E LATIN CAPITAL LETTER E 40 | 0046 F LATIN CAPITAL LETTER F 41 | 0047 G LATIN CAPITAL LETTER G 42 | 0048 H LATIN CAPITAL LETTER H 43 | 0049 I LATIN CAPITAL LETTER I 44 | 004A J LATIN CAPITAL LETTER J 45 | 004B K LATIN CAPITAL LETTER K 46 | 004C L LATIN CAPITAL LETTER L 47 | 004D M LATIN CAPITAL LETTER M 48 | 004E N LATIN CAPITAL LETTER N 49 | 004F O LATIN CAPITAL LETTER O 50 | 0050 P LATIN CAPITAL LETTER P 51 | 0051 Q LATIN CAPITAL LETTER Q 52 | 0052 R LATIN CAPITAL LETTER R 53 | 0053 S LATIN CAPITAL LETTER S 54 | 0054 T LATIN CAPITAL LETTER T 55 | 0055 U LATIN CAPITAL LETTER U 56 | 0056 V LATIN CAPITAL LETTER V 57 | 0057 W LATIN CAPITAL LETTER W 58 | 0058 X LATIN CAPITAL LETTER X 59 | 0059 Y LATIN CAPITAL LETTER Y 60 | 005A Z LATIN CAPITAL LETTER Z 61 | 005B bracketleft LEFT SQUARE BRACKET 62 | 005C backslash REVERSE SOLIDUS 63 | 005D bracketright RIGHT SQUARE BRACKET 64 | 005E asciicircum CIRCUMFLEX ACCENT 65 | 005F underscore LOW LINE 66 | 0060 grave GRAVE ACCENT 67 | 0061 a LATIN SMALL LETTER A 68 | 0062 b LATIN SMALL LETTER B 69 | 0063 c LATIN SMALL LETTER C 70 | 0064 d LATIN SMALL LETTER D 71 | 0065 e LATIN SMALL LETTER E 72 | 0066 f LATIN SMALL LETTER F 73 | 0067 g LATIN SMALL LETTER G 74 | 0068 h LATIN SMALL LETTER H 75 | 0069 i LATIN SMALL LETTER I 76 | 006A j LATIN SMALL LETTER J 77 | 006B k LATIN SMALL LETTER K 78 | 006C l LATIN SMALL LETTER L 79 | 006D m LATIN SMALL LETTER M 80 | 006E n LATIN SMALL LETTER N 81 | 006F o LATIN SMALL LETTER O 82 | 0070 p LATIN SMALL LETTER P 83 | 0071 q LATIN SMALL LETTER Q 84 | 0072 r LATIN SMALL LETTER R 85 | 0073 s LATIN SMALL LETTER S 86 | 0074 t LATIN SMALL LETTER T 87 | 0075 u LATIN SMALL LETTER U 88 | 0076 v LATIN SMALL LETTER V 89 | 0077 w LATIN SMALL LETTER W 90 | 0078 x LATIN SMALL LETTER X 91 | 0079 y LATIN SMALL LETTER Y 92 | 007A z LATIN SMALL LETTER Z 93 | 007B braceleft LEFT CURLY BRACKET 94 | 007C bar VERTICAL LINE 95 | 007D braceright RIGHT CURLY BRACKET 96 | 007E asciitilde TILDE -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/dingbats.py: -------------------------------------------------------------------------------- 1 | 2 | def process(self): 3 | self.replace("MARK") 4 | self.replace("SYMBOL") 5 | self.replace("TRIFOLIATE") 6 | 7 | self.replace("RECTILINEAR", "compas") 8 | 9 | self.edit("TEARDROP-SPOKED", "teardrop") 10 | self.edit("TEARDROP-BARBED", "teardrop") 11 | self.edit("TEARDROP-SHANKED", "teardrop") 12 | 13 | self.edit("BALLOON-SPOKED", "balloon") 14 | self.edit("CLUB-SPOKED", "club") 15 | 16 | self.edit("RIGHT-SHADOWED", "shadow") 17 | self.edit("DROP-SHADOWED", "shadow") 18 | 19 | self.edit("RIGHTWARDS", "right") 20 | self.edit("LEFTWARDS", "left") 21 | self.edit("OPEN-OUTLINED", "outlinedopen") 22 | self.edit("WEDGE-TAILED", "wedge") 23 | self.edit("-FEATHERED", "feathered") 24 | self.edit("NOTCHED", "notched") 25 | 26 | self.edit("FRONT-TILTED", "fronttilted") 27 | self.edit("BACK-TILTED", "backtilted") 28 | 29 | self.edit("RIGHT-SHADED", "rightshaded") 30 | self.edit("LEFT-SHADED", "leftshaded") 31 | 32 | self.edit("CONCAVE-POINTED", "pointed") 33 | self.edit("RIGHT-POINTING", "rightpointed") 34 | self.edit("LEFT-POINTING", "leftpointed") 35 | 36 | self.edit("ROUND-TIPPED", "round") 37 | self.edit("TRIANGLE-HEADED", "triangle") 38 | self.edit("WIDE-HEADED", "wide") 39 | 40 | self.edit("THREE-D", "threeD") 41 | 42 | self.edit("BOTTOM-LIGHTED", "bottomlight") 43 | self.edit("TOP-LIGHTED", "toplight") 44 | 45 | self.edit("SANS-SERIF", "sans") 46 | self.edit("NEGATIVE", "negative") 47 | 48 | self.edit("CURVED UPWARDS", "curveup") 49 | self.edit("CURVED DOWNWARDS", "curvedown") 50 | 51 | self.edit("DRAFTING POINT", "pointed") 52 | 53 | self.edit("TORTOISE SHELL", "shell") 54 | 55 | self.edit("COMMA QUOTATION", "comma") 56 | self.replace("SINGLE") 57 | 58 | self.editToFinal("SOUTH", "S") 59 | self.editToFinal("NORTH", "N") 60 | self.editToFinal("EAST", "E") 61 | self.editToFinal("WEST", "W") 62 | 63 | hasDingbat = self.has("DINGBAT") 64 | 65 | parts = [ 66 | "VICTORY", "WRITING", 67 | "UPPER", "LOWER", "CENTRE", 68 | "RIGHT", "LEFT", 69 | "OUTLINED", "OPEN", "SHADOWED", "POINTED", "DASHED", "SQUAT", "ANGLE", "FLATTENED", "ROTATED", 70 | "BLADE", "STRESS", "CIRCLED", "OPEN", "PINWHEEL", "PETALLED", "PROPELLER", "TIGHT", 71 | 72 | "BLACK", "WHITE", "HEAVY", "LIGHT", "MEDIUM", "DOUBLE", "TURNED", "ORNAMENT" 73 | ] 74 | 75 | if not hasDingbat: 76 | parts.extend([ 77 | "SIXTEEN", "FOUR", "SIX", "EIGHT", "TWELVE", 78 | ]) 79 | 80 | for part in parts: 81 | self.edit(part, part.lower()) 82 | 83 | if hasDingbat: 84 | self.replace("DINGBAT") 85 | self.replace("NUMBER") 86 | self.replace("DIGIT") 87 | # self.final(".dingbat") 88 | 89 | self.replace("AND") 90 | 91 | self.compress() 92 | self.lower() 93 | #self.scriptPrefix() 94 | 95 | if __name__ == "__main__": 96 | from glyphNameFormatter.exporters import printRange 97 | printRange("Dingbats") 98 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/00A00-00A7F gurmukhi.txt: -------------------------------------------------------------------------------- 1 | # Gurmukhi 00A00 - 00A7F 2 | 0A01 guru:adakbindisign GURMUKHI SIGN ADAK BINDI 3 | 0A02 guru:bindisign GURMUKHI SIGN BINDI 4 | 0A03 guru:visarga GURMUKHI SIGN VISARGA 5 | 0A05 guru:a GURMUKHI LETTER A 6 | 0A06 guru:aa GURMUKHI LETTER AA 7 | 0A07 guru:i GURMUKHI LETTER I 8 | 0A08 guru:ii GURMUKHI LETTER II 9 | 0A09 guru:u GURMUKHI LETTER U 10 | 0A0A guru:uu GURMUKHI LETTER UU 11 | 0A0F guru:ee GURMUKHI LETTER EE 12 | 0A10 guru:ai GURMUKHI LETTER AI 13 | 0A13 guru:oo GURMUKHI LETTER OO 14 | 0A14 guru:au GURMUKHI LETTER AU 15 | 0A15 guru:ka GURMUKHI LETTER KA 16 | 0A16 guru:kha GURMUKHI LETTER KHA 17 | 0A17 guru:ga GURMUKHI LETTER GA 18 | 0A18 guru:gha GURMUKHI LETTER GHA 19 | 0A19 guru:nga GURMUKHI LETTER NGA 20 | 0A1A guru:ca GURMUKHI LETTER CA 21 | 0A1B guru:cha GURMUKHI LETTER CHA 22 | 0A1C guru:ja GURMUKHI LETTER JA 23 | 0A1D guru:jha GURMUKHI LETTER JHA 24 | 0A1E guru:nya GURMUKHI LETTER NYA 25 | 0A1F guru:tta GURMUKHI LETTER TTA 26 | 0A20 guru:ttha GURMUKHI LETTER TTHA 27 | 0A21 guru:dda GURMUKHI LETTER DDA 28 | 0A22 guru:ddha GURMUKHI LETTER DDHA 29 | 0A23 guru:nna GURMUKHI LETTER NNA 30 | 0A24 guru:ta GURMUKHI LETTER TA 31 | 0A25 guru:tha GURMUKHI LETTER THA 32 | 0A26 guru:da GURMUKHI LETTER DA 33 | 0A27 guru:dha GURMUKHI LETTER DHA 34 | 0A28 guru:na GURMUKHI LETTER NA 35 | 0A2A guru:pa GURMUKHI LETTER PA 36 | 0A2B guru:pha GURMUKHI LETTER PHA 37 | 0A2C guru:ba GURMUKHI LETTER BA 38 | 0A2D guru:bha GURMUKHI LETTER BHA 39 | 0A2E guru:ma GURMUKHI LETTER MA 40 | 0A2F guru:ya GURMUKHI LETTER YA 41 | 0A30 guru:ra GURMUKHI LETTER RA 42 | 0A32 guru:la GURMUKHI LETTER LA 43 | 0A33 guru:lla GURMUKHI LETTER LLA 44 | 0A35 guru:va GURMUKHI LETTER VA 45 | 0A36 guru:sha GURMUKHI LETTER SHA 46 | 0A38 guru:sa GURMUKHI LETTER SA 47 | 0A39 guru:ha GURMUKHI LETTER HA 48 | 0A3C guru:nukta GURMUKHI SIGN NUKTA 49 | 0A3E guru:aasign GURMUKHI VOWEL SIGN AA 50 | 0A3F guru:isign GURMUKHI VOWEL SIGN I 51 | 0A40 guru:iisign GURMUKHI VOWEL SIGN II 52 | 0A41 guru:usign GURMUKHI VOWEL SIGN U 53 | 0A42 guru:uusign GURMUKHI VOWEL SIGN UU 54 | 0A47 guru:eesign GURMUKHI VOWEL SIGN EE 55 | 0A48 guru:aisign GURMUKHI VOWEL SIGN AI 56 | 0A4B guru:oosign GURMUKHI VOWEL SIGN OO 57 | 0A4C guru:ausign GURMUKHI VOWEL SIGN AU 58 | 0A4D guru:virama GURMUKHI SIGN VIRAMA 59 | 0A51 guru:udaatsign GURMUKHI SIGN UDAAT 60 | 0A59 guru:khha GURMUKHI LETTER KHHA 61 | 0A5A guru:ghha GURMUKHI LETTER GHHA 62 | 0A5B guru:za GURMUKHI LETTER ZA 63 | 0A5C guru:rra GURMUKHI LETTER RRA 64 | 0A5E guru:fa GURMUKHI LETTER FA 65 | 0A66 guru:zero GURMUKHI DIGIT ZERO 66 | 0A67 guru:one GURMUKHI DIGIT ONE 67 | 0A68 guru:two GURMUKHI DIGIT TWO 68 | 0A69 guru:three GURMUKHI DIGIT THREE 69 | 0A6A guru:four GURMUKHI DIGIT FOUR 70 | 0A6B guru:five GURMUKHI DIGIT FIVE 71 | 0A6C guru:six GURMUKHI DIGIT SIX 72 | 0A6D guru:seven GURMUKHI DIGIT SEVEN 73 | 0A6E guru:eight GURMUKHI DIGIT EIGHT 74 | 0A6F guru:nine GURMUKHI DIGIT NINE 75 | 0A70 guru:tippi GURMUKHI TIPPI 76 | 0A71 guru:addak GURMUKHI ADDAK 77 | 0A72 guru:iri GURMUKHI IRI 78 | 0A73 guru:ura GURMUKHI URA 79 | 0A74 guru:ekonkar GURMUKHI EK ONKAR 80 | 0A75 guru:yakashsign GURMUKHI SIGN YAKASH 81 | 0A76 guru:abbreviationsign GURMUKHI ABBREVIATION SIGN -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/02100-0214F letterlike_symbols.txt: -------------------------------------------------------------------------------- 1 | # Letterlike Symbols 02100 - 0214F 2 | 2100 accountof ACCOUNT OF 3 | 2101 addressedsubject ADDRESSED TO THE SUBJECT 4 | 2102 Cdblstruck DOUBLE-STRUCK CAPITAL C 5 | 2103 degreecelsius DEGREE CELSIUS 6 | 2104 centreline CENTRE LINE SYMBOL 7 | 2105 careof CARE OF 8 | 2106 cadauna CADA UNA 9 | 2107 euler EULER CONSTANT 10 | 2108 scruple SCRUPLE 11 | 2109 degreefahrenheit DEGREE FAHRENHEIT 12 | 210A lttr:gscript SCRIPT SMALL G 13 | 210B Hscript SCRIPT CAPITAL H 14 | 210C Hfraktur BLACK-LETTER CAPITAL H 15 | 210D Hdblstruck DOUBLE-STRUCK CAPITAL H 16 | 210E planck PLANCK CONSTANT 17 | 210F plancktwopi PLANCK CONSTANT OVER TWO PI 18 | 2110 Iscript SCRIPT CAPITAL I 19 | 2111 Ifraktur BLACK-LETTER CAPITAL I 20 | 2112 Lscript SCRIPT CAPITAL L 21 | 2113 litre SCRIPT SMALL L 22 | 2114 lbbar L B BAR SYMBOL 23 | 2115 Ndblstruck DOUBLE-STRUCK CAPITAL N 24 | 2116 numero NUMERO SIGN 25 | 2117 soundcopyright SOUND RECORDING COPYRIGHT 26 | 2118 weierstrass SCRIPT CAPITAL P 27 | 2119 Pdblstruck DOUBLE-STRUCK CAPITAL P 28 | 211A Qdblstruck DOUBLE-STRUCK CAPITAL Q 29 | 211B Rscript SCRIPT CAPITAL R 30 | 211C Rfraktur BLACK-LETTER CAPITAL R 31 | 211D Rdblstruck DOUBLE-STRUCK CAPITAL R 32 | 211E prescription PRESCRIPTION TAKE 33 | 211F response RESPONSE 34 | 2120 servicemark SERVICE MARK 35 | 2121 telephone TELEPHONE SIGN 36 | 2122 trademark TRADE MARK SIGN 37 | 2123 versicle VERSICLE 38 | 2124 Zdblstruck DOUBLE-STRUCK CAPITAL Z 39 | 2125 ounce OUNCE SIGN 40 | 2126 ohm OHM SIGN 41 | 2127 ohminverted INVERTED OHM SIGN 42 | 2128 Zfraktur BLACK-LETTER CAPITAL Z 43 | 2129 iotaturned TURNED GREEK SMALL LETTER IOTA 44 | 212A kelvin KELVIN SIGN 45 | 212B angstrom ANGSTROM SIGN 46 | 212C Bscript SCRIPT CAPITAL B 47 | 212D Cfraktur BLACK-LETTER CAPITAL C 48 | 212E estimated ESTIMATED SYMBOL 49 | 212F escript SCRIPT SMALL E 50 | 2130 Escript SCRIPT CAPITAL E 51 | 2131 Fscript SCRIPT CAPITAL F 52 | 2132 Fturned TURNED CAPITAL F 53 | 2133 Mscript SCRIPT CAPITAL M 54 | 2134 oscript SCRIPT SMALL O 55 | 2135 aleph ALEF SYMBOL 56 | 2136 bet BET SYMBOL 57 | 2137 gimel GIMEL SYMBOL 58 | 2138 dalet DALET SYMBOL 59 | 2139 information INFORMATION SOURCE 60 | 213A Qrotated ROTATED CAPITAL Q 61 | 213B facsimile FACSIMILE SIGN 62 | 213C pidblstruck DOUBLE-STRUCK SMALL PI 63 | 213D gammadblstruck DOUBLE-STRUCK SMALL GAMMA 64 | 213E Gammadblstruck DOUBLE-STRUCK CAPITAL GAMMA 65 | 213F Pidblstruck DOUBLE-STRUCK CAPITAL PI 66 | 2140 summationdblstruck DOUBLE-STRUCK N-ARY SUMMATION 67 | 2141 Gturnedsans TURNED SANS-SERIF CAPITAL G 68 | 2142 Lturnedsans TURNED SANS-SERIF CAPITAL L 69 | 2143 Lreversedsans REVERSED SANS-SERIF CAPITAL L 70 | 2144 Yturnedsans TURNED SANS-SERIF CAPITAL Y 71 | 2145 Ddblstruckitalic DOUBLE-STRUCK ITALIC CAPITAL D 72 | 2146 ddblstruckitalic DOUBLE-STRUCK ITALIC SMALL D 73 | 2147 edblstruckitalic DOUBLE-STRUCK ITALIC SMALL E 74 | 2148 idblstruckitalic DOUBLE-STRUCK ITALIC SMALL I 75 | 2149 jdblstruckitalic DOUBLE-STRUCK ITALIC SMALL J 76 | 214A propertyline PROPERTY LINE 77 | 214B ampersandturned TURNED AMPERSAND 78 | 214C per PER SIGN 79 | 214D aktieselskab AKTIESELSKAB 80 | 214E fturned TURNED SMALL F 81 | 214F forsamaritan SYMBOL FOR SAMARITAN SOURCE -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/0FB00-0FB4F alphabetic_presentation_forms.txt: -------------------------------------------------------------------------------- 1 | # Alphabetic Presentation Forms 0FB00 - 0FB4F 2 | FB00 f_f LATIN SMALL LIGATURE FF 3 | FB01 fi LATIN SMALL LIGATURE FI 4 | FB02 fl LATIN SMALL LIGATURE FL 5 | FB03 f_f_i LATIN SMALL LIGATURE FFI 6 | FB04 f_f_l LATIN SMALL LIGATURE FFL 7 | FB05 longs_t LATIN SMALL LIGATURE LONG S T 8 | FB06 s_t LATIN SMALL LIGATURE ST 9 | FB13 men_nowarmn ARMENIAN SMALL LIGATURE MEN NOW 10 | FB14 men_echarmn ARMENIAN SMALL LIGATURE MEN ECH 11 | FB15 men_iniarmn ARMENIAN SMALL LIGATURE MEN INI 12 | FB16 vew_nowarmn ARMENIAN SMALL LIGATURE VEW NOW 13 | FB17 men_xeharmn ARMENIAN SMALL LIGATURE MEN XEH 14 | FB1D yodwithhiriq:hb HEBREW LETTER YOD WITH HIRIQ 15 | FB1E varikajudeospanish:hb HEBREW POINT JUDEO-SPANISH VARIKA 16 | FB1F yod_yod_patah:hb HEBREW LIGATURE YIDDISH YOD YOD PATAH 17 | FB20 ayinalt:hb HEBREW LETTER ALTERNATIVE AYIN 18 | FB21 alefwide:hb HEBREW LETTER WIDE ALEF 19 | FB22 daletwide:hb HEBREW LETTER WIDE DALET 20 | FB23 hewide:hb HEBREW LETTER WIDE HE 21 | FB24 kafwide:hb HEBREW LETTER WIDE KAF 22 | FB25 lamedwide:hb HEBREW LETTER WIDE LAMED 23 | FB26 finalmemwide:hb HEBREW LETTER WIDE FINAL MEM 24 | FB27 reshwide:hb HEBREW LETTER WIDE RESH 25 | FB28 tavwide:hb HEBREW LETTER WIDE TAV 26 | FB29 plussignalt:hb HEBREW LETTER ALTERNATIVE PLUS SIGN 27 | FB2A shinwithshinDot:hb HEBREW LETTER SHIN WITH SHIN DOT 28 | FB2B shinwithsinDot:hb HEBREW LETTER SHIN WITH SIN DOT 29 | FB2C shinwithdageshandshinDot:hb HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT 30 | FB2D shinwithdageshandsinDot:hb HEBREW LETTER SHIN WITH DAGESH AND SIN DOT 31 | FB2E alefwithpatah:hb HEBREW LETTER ALEF WITH PATAH 32 | FB2F alefwithqamats:hb HEBREW LETTER ALEF WITH QAMATS 33 | FB30 alefwithmapiq:hb HEBREW LETTER ALEF WITH MAPIQ 34 | FB31 betwithdagesh:hb HEBREW LETTER BET WITH DAGESH 35 | FB32 gimelwithdagesh:hb HEBREW LETTER GIMEL WITH DAGESH 36 | FB33 daletwithdagesh:hb HEBREW LETTER DALET WITH DAGESH 37 | FB34 hewithmapiq:hb HEBREW LETTER HE WITH MAPIQ 38 | FB35 vavwithdagesh:hb HEBREW LETTER VAV WITH DAGESH 39 | FB36 zayinwithdagesh:hb HEBREW LETTER ZAYIN WITH DAGESH 40 | FB38 tetwithdagesh:hb HEBREW LETTER TET WITH DAGESH 41 | FB39 yodwithdagesh:hb HEBREW LETTER YOD WITH DAGESH 42 | FB3A finalkafwithdagesh:hb HEBREW LETTER FINAL KAF WITH DAGESH 43 | FB3B kafwithdagesh:hb HEBREW LETTER KAF WITH DAGESH 44 | FB3C lamedwithdagesh:hb HEBREW LETTER LAMED WITH DAGESH 45 | FB3E memwithdagesh:hb HEBREW LETTER MEM WITH DAGESH 46 | FB40 nunwithdagesh:hb HEBREW LETTER NUN WITH DAGESH 47 | FB41 samekhwithdagesh:hb HEBREW LETTER SAMEKH WITH DAGESH 48 | FB43 finalpewithdagesh:hb HEBREW LETTER FINAL PE WITH DAGESH 49 | FB44 pewithdagesh:hb HEBREW LETTER PE WITH DAGESH 50 | FB46 tsadiwithdagesh:hb HEBREW LETTER TSADI WITH DAGESH 51 | FB47 qofwithdagesh:hb HEBREW LETTER QOF WITH DAGESH 52 | FB48 reshwithdagesh:hb HEBREW LETTER RESH WITH DAGESH 53 | FB49 shinwithdagesh:hb HEBREW LETTER SHIN WITH DAGESH 54 | FB4A tavwithdagesh:hb HEBREW LETTER TAV WITH DAGESH 55 | FB4B vavwithholam:hb HEBREW LETTER VAV WITH HOLAM 56 | FB4C betwithrafe:hb HEBREW LETTER BET WITH RAFE 57 | FB4D kafwithrafe:hb HEBREW LETTER KAF WITH RAFE 58 | FB4E pewithrafe:hb HEBREW LETTER PE WITH RAFE 59 | FB4F ligaturealeflamed:hb HEBREW LIGATURE ALEF LAMED -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/02D80-02DDF ethiopic_extended.txt: -------------------------------------------------------------------------------- 1 | # Ethiopic Extended 02D80 - 02DDF 2 | 2D80 ethi:loa ETHIOPIC SYLLABLE LOA 3 | 2D81 ethi:moa ETHIOPIC SYLLABLE MOA 4 | 2D82 ethi:roa ETHIOPIC SYLLABLE ROA 5 | 2D83 ethi:soa ETHIOPIC SYLLABLE SOA 6 | 2D84 ethi:shoa ETHIOPIC SYLLABLE SHOA 7 | 2D85 ethi:boa ETHIOPIC SYLLABLE BOA 8 | 2D86 ethi:toa ETHIOPIC SYLLABLE TOA 9 | 2D87 ethi:coa ETHIOPIC SYLLABLE COA 10 | 2D88 ethi:noa ETHIOPIC SYLLABLE NOA 11 | 2D89 ethi:nyoa ETHIOPIC SYLLABLE NYOA 12 | 2D8A ethi:oaglottal ETHIOPIC SYLLABLE GLOTTAL OA 13 | 2D8B ethi:zoa ETHIOPIC SYLLABLE ZOA 14 | 2D8C ethi:doa ETHIOPIC SYLLABLE DOA 15 | 2D8D ethi:ddoa ETHIOPIC SYLLABLE DDOA 16 | 2D8E ethi:joa ETHIOPIC SYLLABLE JOA 17 | 2D8F ethi:thoa ETHIOPIC SYLLABLE THOA 18 | 2D90 ethi:choa ETHIOPIC SYLLABLE CHOA 19 | 2D91 ethi:phoa ETHIOPIC SYLLABLE PHOA 20 | 2D92 ethi:poa ETHIOPIC SYLLABLE POA 21 | 2D93 ethi:ggwa ETHIOPIC SYLLABLE GGWA 22 | 2D94 ethi:ggwi ETHIOPIC SYLLABLE GGWI 23 | 2D95 ethi:ggwee ETHIOPIC SYLLABLE GGWEE 24 | 2D96 ethi:ggwe ETHIOPIC SYLLABLE GGWE 25 | 2DA0 ethi:ssa ETHIOPIC SYLLABLE SSA 26 | 2DA1 ethi:ssu ETHIOPIC SYLLABLE SSU 27 | 2DA2 ethi:ssi ETHIOPIC SYLLABLE SSI 28 | 2DA3 ethi:ssaa ETHIOPIC SYLLABLE SSAA 29 | 2DA4 ethi:ssee ETHIOPIC SYLLABLE SSEE 30 | 2DA5 ethi:sse ETHIOPIC SYLLABLE SSE 31 | 2DA6 ethi:sso ETHIOPIC SYLLABLE SSO 32 | 2DA8 ethi:cca ETHIOPIC SYLLABLE CCA 33 | 2DA9 ethi:ccu ETHIOPIC SYLLABLE CCU 34 | 2DAA ethi:cci ETHIOPIC SYLLABLE CCI 35 | 2DAB ethi:ccaa ETHIOPIC SYLLABLE CCAA 36 | 2DAC ethi:ccee ETHIOPIC SYLLABLE CCEE 37 | 2DAD ethi:cce ETHIOPIC SYLLABLE CCE 38 | 2DAE ethi:cco ETHIOPIC SYLLABLE CCO 39 | 2DB0 ethi:zza ETHIOPIC SYLLABLE ZZA 40 | 2DB1 ethi:zzu ETHIOPIC SYLLABLE ZZU 41 | 2DB2 ethi:zzi ETHIOPIC SYLLABLE ZZI 42 | 2DB3 ethi:zzaa ETHIOPIC SYLLABLE ZZAA 43 | 2DB4 ethi:zzee ETHIOPIC SYLLABLE ZZEE 44 | 2DB5 ethi:zze ETHIOPIC SYLLABLE ZZE 45 | 2DB6 ethi:zzo ETHIOPIC SYLLABLE ZZO 46 | 2DB8 ethi:ccha ETHIOPIC SYLLABLE CCHA 47 | 2DB9 ethi:cchu ETHIOPIC SYLLABLE CCHU 48 | 2DBA ethi:cchi ETHIOPIC SYLLABLE CCHI 49 | 2DBB ethi:cchaa ETHIOPIC SYLLABLE CCHAA 50 | 2DBC ethi:cchee ETHIOPIC SYLLABLE CCHEE 51 | 2DBD ethi:cche ETHIOPIC SYLLABLE CCHE 52 | 2DBE ethi:ccho ETHIOPIC SYLLABLE CCHO 53 | 2DC0 ethi:qya ETHIOPIC SYLLABLE QYA 54 | 2DC1 ethi:qyu ETHIOPIC SYLLABLE QYU 55 | 2DC2 ethi:qyi ETHIOPIC SYLLABLE QYI 56 | 2DC3 ethi:qyaa ETHIOPIC SYLLABLE QYAA 57 | 2DC4 ethi:qyee ETHIOPIC SYLLABLE QYEE 58 | 2DC5 ethi:qye ETHIOPIC SYLLABLE QYE 59 | 2DC6 ethi:qyo ETHIOPIC SYLLABLE QYO 60 | 2DC8 ethi:kya ETHIOPIC SYLLABLE KYA 61 | 2DC9 ethi:kyu ETHIOPIC SYLLABLE KYU 62 | 2DCA ethi:kyi ETHIOPIC SYLLABLE KYI 63 | 2DCB ethi:kyaa ETHIOPIC SYLLABLE KYAA 64 | 2DCC ethi:kyee ETHIOPIC SYLLABLE KYEE 65 | 2DCD ethi:kye ETHIOPIC SYLLABLE KYE 66 | 2DCE ethi:kyo ETHIOPIC SYLLABLE KYO 67 | 2DD0 ethi:xya ETHIOPIC SYLLABLE XYA 68 | 2DD1 ethi:xyu ETHIOPIC SYLLABLE XYU 69 | 2DD2 ethi:xyi ETHIOPIC SYLLABLE XYI 70 | 2DD3 ethi:xyaa ETHIOPIC SYLLABLE XYAA 71 | 2DD4 ethi:xyee ETHIOPIC SYLLABLE XYEE 72 | 2DD5 ethi:xye ETHIOPIC SYLLABLE XYE 73 | 2DD6 ethi:xyo ETHIOPIC SYLLABLE XYO 74 | 2DD8 ethi:gya ETHIOPIC SYLLABLE GYA 75 | 2DD9 ethi:gyu ETHIOPIC SYLLABLE GYU 76 | 2DDA ethi:gyi ETHIOPIC SYLLABLE GYI 77 | 2DDB ethi:gyaa ETHIOPIC SYLLABLE GYAA 78 | 2DDC ethi:gyee ETHIOPIC SYLLABLE GYEE 79 | 2DDD ethi:gye ETHIOPIC SYLLABLE GYE 80 | 2DDE ethi:gyo ETHIOPIC SYLLABLE GYO -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/data/buildFlatUnicodeList.py: -------------------------------------------------------------------------------- 1 | from __future__ import print_function 2 | import os 3 | import sys 4 | import tempfile 5 | from zipfile import ZipFile 6 | from xml.etree import cElementTree as ET 7 | from argparse import ArgumentParser, RawDescriptionHelpFormatter 8 | try: 9 | from urllib2 import urlopen 10 | except ImportError: 11 | from urllib.request import urlopen 12 | 13 | __doc__ = """ 14 | This will parse the large ucd xml from unicode.org 15 | into a simple list that is workable and 16 | is fair enough for download and embedding. 17 | 18 | starts with the # unicode description/version 19 | 20 | format 21 | \t 22 | """ 23 | 24 | URL = "http://www.unicode.org/Public/{version}/ucdxml/ucd.all.flat.zip" 25 | 26 | UNICODE_VERSION = "16.0.0" 27 | UCD_ZIP_FILE = "ucd.all.flat.zip" 28 | UCD_FILE = UCD_ZIP_FILE[:-3] + "xml" 29 | FLAT_FILE = "flatUnicode.txt" 30 | 31 | parser = ArgumentParser(description=__doc__, 32 | formatter_class=RawDescriptionHelpFormatter) 33 | group = parser.add_mutually_exclusive_group(required=False) 34 | group.add_argument("-u", "--unicode-version", 35 | help="Unicode version to use for download and processing") 36 | group.add_argument("-i", "--input", metavar="UCD_FILE", 37 | help="Path to copy of {ucd_file} for processing. " 38 | "Use if you already have an up-to-date local copy of " 39 | "{ucd_file}.".format(ucd_file=UCD_FILE)) 40 | options = parser.parse_args() 41 | 42 | if options.input: 43 | path = options.input 44 | else: 45 | tempdir = tempfile.mkdtemp() 46 | filename = os.path.join(tempdir, UCD_ZIP_FILE) 47 | if options.unicode_version: 48 | version = options.unicode_version 49 | else: 50 | version = UNICODE_VERSION 51 | print(">> Downloading {} to {} (version {})".format(UCD_ZIP_FILE, filename, version)) 52 | print(URL.format(version=version)) 53 | url = urlopen(URL.format(version=version)) 54 | with open(filename, "wb") as fp: 55 | blocksize = 8192 56 | while True: 57 | buffer = url.read(blocksize) 58 | if not buffer: 59 | break 60 | fp.write(buffer) 61 | zipped = ZipFile(filename) 62 | print(">> Extracting {} to {}" 63 | .format(UCD_FILE, os.path.join(tempdir, UCD_FILE))) 64 | path = zipped.extract(UCD_FILE, tempdir) 65 | 66 | 67 | print(">> Building {} from {}".format(FLAT_FILE, path)) 68 | tree = ET.parse(path) 69 | 70 | flat = [] 71 | for i in tree.iter(): 72 | if i.tag.endswith("description"): 73 | flat.insert(0, "# %s" % i.text) 74 | if i.tag.endswith("char"): 75 | n = i.attrib.get("na") 76 | if n: 77 | uc = i.attrib.get("uc") 78 | if uc == "#": 79 | uc = '' 80 | lc = i.attrib.get("lc") 81 | if lc == "#": 82 | lc = '' 83 | mth = i.attrib.get('Math') 84 | if mth != "N": 85 | mth = "M" 86 | else: 87 | mth = "" 88 | # codepoint / tab / uppercase / tab / lowercase / tab / category / tab / name 89 | flat.append("%s\t%s\t%s\t%s\t%s\t%s" % (i.attrib.get("cp"), uc, lc, i.attrib.get("gc"), mth, n)) 90 | 91 | 92 | f = open(FLAT_FILE, "w") 93 | f.write("\n".join(flat)) 94 | f.close() 95 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/013A0-013FF cherokee.txt: -------------------------------------------------------------------------------- 1 | # Cherokee 013A0 - 013FF 2 | 13A0 cher:a CHEROKEE LETTER A 3 | 13A1 cher:e CHEROKEE LETTER E 4 | 13A2 cher:i CHEROKEE LETTER I 5 | 13A3 cher:o CHEROKEE LETTER O 6 | 13A4 cher:u CHEROKEE LETTER U 7 | 13A5 cher:v CHEROKEE LETTER V 8 | 13A6 cher:ga CHEROKEE LETTER GA 9 | 13A7 cher:ka CHEROKEE LETTER KA 10 | 13A8 cher:ge CHEROKEE LETTER GE 11 | 13A9 cher:gi CHEROKEE LETTER GI 12 | 13AA cher:go CHEROKEE LETTER GO 13 | 13AB cher:gu CHEROKEE LETTER GU 14 | 13AC cher:gv CHEROKEE LETTER GV 15 | 13AD cher:ha CHEROKEE LETTER HA 16 | 13AE cher:he CHEROKEE LETTER HE 17 | 13AF cher:hi CHEROKEE LETTER HI 18 | 13B0 cher:ho CHEROKEE LETTER HO 19 | 13B1 cher:hu CHEROKEE LETTER HU 20 | 13B2 cher:hv CHEROKEE LETTER HV 21 | 13B3 cher:la CHEROKEE LETTER LA 22 | 13B4 cher:le CHEROKEE LETTER LE 23 | 13B5 cher:li CHEROKEE LETTER LI 24 | 13B6 cher:lo CHEROKEE LETTER LO 25 | 13B7 cher:lu CHEROKEE LETTER LU 26 | 13B8 cher:lv CHEROKEE LETTER LV 27 | 13B9 cher:ma CHEROKEE LETTER MA 28 | 13BA cher:me CHEROKEE LETTER ME 29 | 13BB cher:mi CHEROKEE LETTER MI 30 | 13BC cher:mo CHEROKEE LETTER MO 31 | 13BD cher:mu CHEROKEE LETTER MU 32 | 13BE cher:na CHEROKEE LETTER NA 33 | 13BF cher:hna CHEROKEE LETTER HNA 34 | 13C0 cher:nah CHEROKEE LETTER NAH 35 | 13C1 cher:ne CHEROKEE LETTER NE 36 | 13C2 cher:ni CHEROKEE LETTER NI 37 | 13C3 cher:no CHEROKEE LETTER NO 38 | 13C4 cher:nu CHEROKEE LETTER NU 39 | 13C5 cher:nv CHEROKEE LETTER NV 40 | 13C6 cher:qua CHEROKEE LETTER QUA 41 | 13C7 cher:que CHEROKEE LETTER QUE 42 | 13C8 cher:qui CHEROKEE LETTER QUI 43 | 13C9 cher:quo CHEROKEE LETTER QUO 44 | 13CA cher:quu CHEROKEE LETTER QUU 45 | 13CB cher:quv CHEROKEE LETTER QUV 46 | 13CC cher:sa CHEROKEE LETTER SA 47 | 13CD cher:s CHEROKEE LETTER S 48 | 13CE cher:se CHEROKEE LETTER SE 49 | 13CF cher:si CHEROKEE LETTER SI 50 | 13D0 cher:so CHEROKEE LETTER SO 51 | 13D1 cher:su CHEROKEE LETTER SU 52 | 13D2 cher:sv CHEROKEE LETTER SV 53 | 13D3 cher:da CHEROKEE LETTER DA 54 | 13D4 cher:ta CHEROKEE LETTER TA 55 | 13D5 cher:de CHEROKEE LETTER DE 56 | 13D6 cher:te CHEROKEE LETTER TE 57 | 13D7 cher:di CHEROKEE LETTER DI 58 | 13D8 cher:ti CHEROKEE LETTER TI 59 | 13D9 cher:do CHEROKEE LETTER DO 60 | 13DA cher:du CHEROKEE LETTER DU 61 | 13DB cher:dv CHEROKEE LETTER DV 62 | 13DC cher:dla CHEROKEE LETTER DLA 63 | 13DD cher:tla CHEROKEE LETTER TLA 64 | 13DE cher:tle CHEROKEE LETTER TLE 65 | 13DF cher:tli CHEROKEE LETTER TLI 66 | 13E0 cher:tlo CHEROKEE LETTER TLO 67 | 13E1 cher:tlu CHEROKEE LETTER TLU 68 | 13E2 cher:tlv CHEROKEE LETTER TLV 69 | 13E3 cher:tsa CHEROKEE LETTER TSA 70 | 13E4 cher:tse CHEROKEE LETTER TSE 71 | 13E5 cher:tsi CHEROKEE LETTER TSI 72 | 13E6 cher:tso CHEROKEE LETTER TSO 73 | 13E7 cher:tsu CHEROKEE LETTER TSU 74 | 13E8 cher:tsv CHEROKEE LETTER TSV 75 | 13E9 cher:wa CHEROKEE LETTER WA 76 | 13EA cher:we CHEROKEE LETTER WE 77 | 13EB cher:wi CHEROKEE LETTER WI 78 | 13EC cher:wo CHEROKEE LETTER WO 79 | 13ED cher:wu CHEROKEE LETTER WU 80 | 13EE cher:wv CHEROKEE LETTER WV 81 | 13EF cher:ya CHEROKEE LETTER YA 82 | 13F0 cher:ye CHEROKEE LETTER YE 83 | 13F1 cher:yi CHEROKEE LETTER YI 84 | 13F2 cher:yo CHEROKEE LETTER YO 85 | 13F3 cher:yu CHEROKEE LETTER YU 86 | 13F4 cher:yv CHEROKEE LETTER YV 87 | 13F5 cher:mv CHEROKEE LETTER MV 88 | 13F8 cher:yesmall CHEROKEE SMALL LETTER YE 89 | 13F9 cher:yismall CHEROKEE SMALL LETTER YI 90 | 13FA cher:yosmall CHEROKEE SMALL LETTER YO 91 | 13FB cher:yusmall CHEROKEE SMALL LETTER YU 92 | 13FC cher:yvsmall CHEROKEE SMALL LETTER YV 93 | 13FD cher:mvsmall CHEROKEE SMALL LETTER MV -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/cyrillic.py: -------------------------------------------------------------------------------- 1 | 2 | ukrainian = "ukr" 3 | 4 | 5 | def process(self): 6 | self.edit("CYRILLIC") 7 | if self.uniNumber == 0x042D: 8 | self.uniNameProcessed = "Ereversed" 9 | return 10 | if self.uniNumber == 0x044D: 11 | self.uniNameProcessed = "ereversed" 12 | return 13 | 14 | self.edit("CAPITAL LIGATURE EN GHE", "Enge") 15 | self.edit("SMALL LIGATURE EN GHE", "enge") 16 | self.edit("CAPITAL LIGATURE A IE", "Aie") 17 | self.edit("SMALL LIGATURE A IE", "aie") 18 | self.edit("CAPITAL LIGATURE TE TSE", "Tetse") 19 | self.edit("SMALL LIGATURE TE TSE", "tetse") 20 | self.edit("CAPITAL LETTER HARD SIGN", "Hard") 21 | self.edit("CAPITAL LETTER SOFT SIGN", "Soft") 22 | 23 | # corrections from Ilya 24 | self.edit("CAPITAL LETTER UKRAINIAN IE", "E%s" % ukrainian) 25 | self.edit("SMALL LETTER UKRAINIAN IE", "e%s" % ukrainian) 26 | self.edit("CAPITAL LETTER YI", "Y%s" % ukrainian) 27 | self.edit("SMALL LETTER YI", "y%s" % ukrainian) 28 | self.edit("CAPITAL LETTER HA WITH DESCENDER", "Xatail") 29 | self.edit("SMALL LETTER HA WITH DESCENDER", "xatail") 30 | self.edit("CAPITAL LETTER CHE WITH VERTICAL STROKE", "Chevert") 31 | self.edit("SMALL LETTER CHE WITH VERTICAL STROKE", "chevert") 32 | self.edit("CAPITAL LETTER E WITH DIAERESIS", "Ereverseddieresis") 33 | self.edit("SMALL LETTER E WITH DIAERESIS", "ereverseddieresis") 34 | 35 | self.edit("CAPITAL LETTER YERU", "Ylong") 36 | self.edit("SMALL LETTER YERU", "ylong") 37 | self.edit("CAPITAL LETTER GHE", "Ge") 38 | self.edit("SMALL LETTER GHE", "ge") 39 | 40 | self.edit("SMALL LETTER PALOCHKA", "palochka") 41 | self.edit("LETTER PALOCHKA", "Palochka") 42 | 43 | self.edit("BIG", "big") # Yus 44 | self.edit("LITTLE", "little") # yus 45 | self.edit("BARRED", "bar") 46 | self.edit("STRAIGHT", "straight") 47 | self.edit("SHORT", "short") 48 | self.edit("IOTIFIED", "iotified") 49 | self.edit("WITH TITLO", 'titlo') 50 | self.edit("TITLO", 'titlo') 51 | 52 | self.edit("ABKHASIAN", "abkh") 53 | self.edit("BASHKIR", "bashk") 54 | self.edit("KHAKASSIAN", "khakas") 55 | 56 | self.edit("WITH UPTURN", "up") 57 | self.edit("WITH DESCENDER", "tail") 58 | self.edit("WITH VERTICAL STROKE", "verticalstroke") 59 | self.edit("WITH TAIL", "sharptail") 60 | self.edit("WITH TICK", "tick") 61 | self.edit("WITH MIDDLE HOOK", "hook") 62 | 63 | self.edit("HARD SIGN", "hard") 64 | self.edit("SOFT SIGN", "soft") 65 | 66 | self.edit("ROUND", "round") 67 | self.edit("KOMI", 'komi') 68 | self.edit("BYELORUSSIAN-UKRAINIAN", ukrainian) 69 | self.edit("UKRAINIAN", "ukr") 70 | 71 | self.edit("ALEUT", "aleut") 72 | 73 | self.edit("HUNDRED THOUSANDS SIGN", "hundredthousands") 74 | self.edit("MILLIONS SIGN", "millions") 75 | self.edit("THOUSANDS SIGN", "thousands") 76 | self.edit("POKRYTIE", "pokrytie") 77 | self.edit("PALATALIZATION", "palat") 78 | self.edit("DASIA PNEUMATA", "dasia") 79 | self.edit("PSILI PNEUMATA", "psili") 80 | 81 | self.edit("COMBINING", "cmb") 82 | 83 | self.processAs("Helper Diacritics") 84 | 85 | self.handleCase() 86 | # cleanup 87 | self.edit("CAPITAL") 88 | self.edit("LETTER") 89 | self.scriptPrefix() 90 | 91 | if __name__ == "__main__": 92 | from glyphNameFormatter.exporters import printRange 93 | printRange("Cyrillic") 94 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/00B00-00B7F oriya.txt: -------------------------------------------------------------------------------- 1 | # Oriya 00B00 - 00B7F 2 | 0B01 orya:candrabindu ORIYA SIGN CANDRABINDU 3 | 0B02 orya:anusvara ORIYA SIGN ANUSVARA 4 | 0B03 orya:visarga ORIYA SIGN VISARGA 5 | 0B05 orya:a ORIYA LETTER A 6 | 0B06 orya:aa ORIYA LETTER AA 7 | 0B07 orya:i ORIYA LETTER I 8 | 0B08 orya:ii ORIYA LETTER II 9 | 0B09 orya:u ORIYA LETTER U 10 | 0B0A orya:uu ORIYA LETTER UU 11 | 0B0B orya:vocalicr ORIYA LETTER VOCALIC R 12 | 0B0C orya:vocalicl ORIYA LETTER VOCALIC L 13 | 0B0F orya:e ORIYA LETTER E 14 | 0B10 orya:ai ORIYA LETTER AI 15 | 0B13 orya:o ORIYA LETTER O 16 | 0B14 orya:au ORIYA LETTER AU 17 | 0B15 orya:ka ORIYA LETTER KA 18 | 0B16 orya:kha ORIYA LETTER KHA 19 | 0B17 orya:ga ORIYA LETTER GA 20 | 0B18 orya:gha ORIYA LETTER GHA 21 | 0B19 orya:nga ORIYA LETTER NGA 22 | 0B1A orya:ca ORIYA LETTER CA 23 | 0B1B orya:cha ORIYA LETTER CHA 24 | 0B1C orya:ja ORIYA LETTER JA 25 | 0B1D orya:jha ORIYA LETTER JHA 26 | 0B1E orya:nya ORIYA LETTER NYA 27 | 0B1F orya:tta ORIYA LETTER TTA 28 | 0B20 orya:ttha ORIYA LETTER TTHA 29 | 0B21 orya:dda ORIYA LETTER DDA 30 | 0B22 orya:ddha ORIYA LETTER DDHA 31 | 0B23 orya:nna ORIYA LETTER NNA 32 | 0B24 orya:ta ORIYA LETTER TA 33 | 0B25 orya:tha ORIYA LETTER THA 34 | 0B26 orya:da ORIYA LETTER DA 35 | 0B27 orya:dha ORIYA LETTER DHA 36 | 0B28 orya:na ORIYA LETTER NA 37 | 0B2A orya:pa ORIYA LETTER PA 38 | 0B2B orya:pha ORIYA LETTER PHA 39 | 0B2C orya:ba ORIYA LETTER BA 40 | 0B2D orya:bha ORIYA LETTER BHA 41 | 0B2E orya:ma ORIYA LETTER MA 42 | 0B2F orya:ya ORIYA LETTER YA 43 | 0B30 orya:ra ORIYA LETTER RA 44 | 0B32 orya:la ORIYA LETTER LA 45 | 0B33 orya:lla ORIYA LETTER LLA 46 | 0B35 orya:va ORIYA LETTER VA 47 | 0B36 orya:sha ORIYA LETTER SHA 48 | 0B37 orya:ssa ORIYA LETTER SSA 49 | 0B38 orya:sa ORIYA LETTER SA 50 | 0B39 orya:ha ORIYA LETTER HA 51 | 0B3C orya:nukta ORIYA SIGN NUKTA 52 | 0B3D orya:avagraha ORIYA SIGN AVAGRAHA 53 | 0B3E orya:aasign ORIYA VOWEL SIGN AA 54 | 0B3F orya:isign ORIYA VOWEL SIGN I 55 | 0B40 orya:iisign ORIYA VOWEL SIGN II 56 | 0B41 orya:usign ORIYA VOWEL SIGN U 57 | 0B42 orya:uusign ORIYA VOWEL SIGN UU 58 | 0B43 orya:vocalicrsign ORIYA VOWEL SIGN VOCALIC R 59 | 0B44 orya:vocalicrrsign ORIYA VOWEL SIGN VOCALIC RR 60 | 0B47 orya:esign ORIYA VOWEL SIGN E 61 | 0B48 orya:aisign ORIYA VOWEL SIGN AI 62 | 0B4B orya:osign ORIYA VOWEL SIGN O 63 | 0B4C orya:ausign ORIYA VOWEL SIGN AU 64 | 0B4D orya:virama ORIYA SIGN VIRAMA 65 | 0B55 orya:signoverline ORIYA SIGN OVERLINE 66 | 0B56 orya:ailengthmark ORIYA AI LENGTH MARK 67 | 0B57 orya:aulengthmark ORIYA AU LENGTH MARK 68 | 0B5C orya:rra ORIYA LETTER RRA 69 | 0B5D orya:rha ORIYA LETTER RHA 70 | 0B5F orya:yya ORIYA LETTER YYA 71 | 0B60 orya:vocalicrr ORIYA LETTER VOCALIC RR 72 | 0B61 orya:vocalicll ORIYA LETTER VOCALIC LL 73 | 0B62 orya:vocaliclsign ORIYA VOWEL SIGN VOCALIC L 74 | 0B63 orya:vocalicllsign ORIYA VOWEL SIGN VOCALIC LL 75 | 0B66 orya:zero ORIYA DIGIT ZERO 76 | 0B67 orya:one ORIYA DIGIT ONE 77 | 0B68 orya:two ORIYA DIGIT TWO 78 | 0B69 orya:three ORIYA DIGIT THREE 79 | 0B6A orya:four ORIYA DIGIT FOUR 80 | 0B6B orya:five ORIYA DIGIT FIVE 81 | 0B6C orya:six ORIYA DIGIT SIX 82 | 0B6D orya:seven ORIYA DIGIT SEVEN 83 | 0B6E orya:eight ORIYA DIGIT EIGHT 84 | 0B6F orya:nine ORIYA DIGIT NINE 85 | 0B70 orya:isshar ORIYA ISSHAR 86 | 0B71 orya:wa ORIYA LETTER WA 87 | 0B72 orya:onequarter ORIYA FRACTION ONE QUARTER 88 | 0B73 orya:onehalf ORIYA FRACTION ONE HALF 89 | 0B74 orya:threequarters ORIYA FRACTION THREE QUARTERS 90 | 0B75 orya:onesixteenth ORIYA FRACTION ONE SIXTEENTH 91 | 0B76 orya:oneeighth ORIYA FRACTION ONE EIGHTH 92 | 0B77 orya:threesixteenths ORIYA FRACTION THREE SIXTEENTHS -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/0AB30-0AB6F latin_extended-e.txt: -------------------------------------------------------------------------------- 1 | # Latin Extended-E 0AB30 - 0AB6F 2 | AB30 redalphabar LATIN SMALL LETTER BARRED ALPHA 3 | AB31 areversedschwa LATIN SMALL LETTER A REVERSED-SCHWA 4 | AB32 efractur LATIN SMALL LETTER BLACKLETTER E 5 | AB33 redebar LATIN SMALL LETTER BARRED E 6 | AB34 eflourish LATIN SMALL LETTER E WITH FLOURISH 7 | AB35 flenis LATIN SMALL LETTER LENIS F 8 | AB36 gtailscript LATIN SMALL LETTER SCRIPT G WITH CROSSED-TAIL 9 | AB37 llazyinverteds LATIN SMALL LETTER L WITH INVERTED LAZY S 10 | AB38 lmiddledbltilde LATIN SMALL LETTER L WITH DOUBLE MIDDLE TILDE 11 | AB39 lmiddlering LATIN SMALL LETTER L WITH MIDDLE RING 12 | AB3A mtail LATIN SMALL LETTER M WITH CROSSED-TAIL 13 | AB3B ntail LATIN SMALL LETTER N WITH CROSSED-TAIL 14 | AB3C engtail LATIN SMALL LETTER ENG WITH CROSSED-TAIL 15 | AB3D ofractur LATIN SMALL LETTER BLACKLETTER O 16 | AB3E ofracturstroke LATIN SMALL LETTER BLACKLETTER O WITH STROKE 17 | AB3F ostrokeopen LATIN SMALL LETTER OPEN O WITH STROKE 18 | AB40 oeinverted LATIN SMALL LETTER INVERTED OE 19 | AB41 oestroketurned LATIN SMALL LETTER TURNED OE WITH STROKE 20 | AB42 oehorizontalstroketurned LATIN SMALL LETTER TURNED OE WITH HORIZONTAL STROKE 21 | AB43 ooopenturned LATIN SMALL LETTER TURNED O OPEN-O 22 | AB44 ooopenstroketurned LATIN SMALL LETTER TURNED O OPEN-O WITH STROKE 23 | AB45 stirrupr LATIN SMALL LETTER STIRRUP R 24 | AB46 Rrightlegsmall LATIN LETTER SMALL CAPITAL R WITH RIGHT LEG 25 | AB47 routhandle LATIN SMALL LETTER R WITHOUT HANDLE 26 | AB48 rdbl LATIN SMALL LETTER DOUBLE R 27 | AB49 rtail LATIN SMALL LETTER R WITH CROSSED-TAIL 28 | AB4A rtaildbl LATIN SMALL LETTER DOUBLE R WITH CROSSED-TAIL 29 | AB4B rscript LATIN SMALL LETTER SCRIPT R 30 | AB4C rringscript LATIN SMALL LETTER SCRIPT R WITH RING 31 | AB4D baselineesh LATIN SMALL LETTER BASELINE ESH 32 | AB4E urightlegshort LATIN SMALL LETTER U WITH SHORT RIGHT LEG 33 | AB4F urightlegbarshort LATIN SMALL LETTER U BAR WITH SHORT RIGHT LEG 34 | AB50 ui LATIN SMALL LETTER UI 35 | AB51 uiturned LATIN SMALL LETTER TURNED UI 36 | AB52 ulefthook LATIN SMALL LETTER U WITH LEFT HOOK 37 | AB53 ltgr:chi LATIN SMALL LETTER CHI 38 | AB54 chilowrightring LATIN SMALL LETTER CHI WITH LOW RIGHT RING 39 | AB55 chilowleftserif LATIN SMALL LETTER CHI WITH LOW LEFT SERIF 40 | AB56 xlowrightring LATIN SMALL LETTER X WITH LOW RIGHT RING 41 | AB57 xlongleftleg LATIN SMALL LETTER X WITH LONG LEFT LEG 42 | AB58 xlongleftlegandlowrightring LATIN SMALL LETTER X WITH LONG LEFT LEG AND LOW RIGHT RING 43 | AB59 xlongleftlegserif LATIN SMALL LETTER X WITH LONG LEFT LEG WITH SERIF 44 | AB5A yrightlegshort LATIN SMALL LETTER Y WITH SHORT RIGHT LEG 45 | AB5B breveinvertedmod MODIFIER BREVE WITH INVERTED BREVE 46 | AB5C hengmod MODIFIER LETTER SMALL HENG 47 | AB5D llazyinvertedsmod MODIFIER LETTER SMALL L WITH INVERTED LAZY S 48 | AB5E lmiddletildemod MODIFIER LETTER SMALL L WITH MIDDLE TILDE 49 | AB5F ulefthookmod MODIFIER LETTER SMALL U WITH LEFT HOOK 50 | AB60 sakhayat LATIN SMALL LETTER SAKHA YAT 51 | AB61 iotifiede LATIN SMALL LETTER IOTIFIED E 52 | AB62 oeopen LATIN SMALL LETTER OPEN OE 53 | AB63 uo LATIN SMALL LETTER UO 54 | AB64 alphainverted LATIN SMALL LETTER INVERTED ALPHA 55 | AB65 Omegasmall GREEK LETTER SMALL CAPITAL OMEGA 56 | AB66 dzdigraphretroflexhook LATIN SMALL LETTER DZ DIGRAPH WITH RETROFLEX HOOK 57 | AB67 tsdigraphretroflexhook LATIN SMALL LETTER TS DIGRAPH WITH RETROFLEX HOOK 58 | AB68 rmiddletildeturned LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE 59 | AB69 wturnedmod MODIFIER LETTER SMALL TURNED W 60 | AB6A modLetterLeftTack MODIFIER LETTER LEFT TACK 61 | AB6B modLetterRightTack MODIFIER LETTER RIGHT TACK -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/03000-0303F cjk_symbols_and_punctuation.txt: -------------------------------------------------------------------------------- 1 | # CJK Symbols and Punctuation 03000 - 0303F 2 | 3000 ideographicspace IDEOGRAPHIC SPACE 3 | 3001 ideographiccomma IDEOGRAPHIC COMMA 4 | 3002 ideographicperiod IDEOGRAPHIC FULL STOP 5 | 3003 dittomark DITTO MARK 6 | 3004 jis JAPANESE INDUSTRIAL STANDARD SYMBOL 7 | 3005 ideographiciterationmark IDEOGRAPHIC ITERATION MARK 8 | 3006 ideographicclose IDEOGRAPHIC CLOSING MARK 9 | 3007 ideographiczero IDEOGRAPHIC NUMBER ZERO 10 | 3008 anglebracketleft LEFT ANGLE BRACKET 11 | 3009 anglebracketright RIGHT ANGLE BRACKET 12 | 300A dblanglebracketleft LEFT DOUBLE ANGLE BRACKET 13 | 300B dblanglebracketright RIGHT DOUBLE ANGLE BRACKET 14 | 300C cornerbracketleft LEFT CORNER BRACKET 15 | 300D cornerbracketright RIGHT CORNER BRACKET 16 | 300E whitecornerbracketleft LEFT WHITE CORNER BRACKET 17 | 300F whitecornerbracketright RIGHT WHITE CORNER BRACKET 18 | 3010 blacklenticularbracketleft LEFT BLACK LENTICULAR BRACKET 19 | 3011 blacklenticularbracketright RIGHT BLACK LENTICULAR BRACKET 20 | 3012 postalmark POSTAL MARK 21 | 3013 getamark GETA MARK 22 | 3014 tortoiseshellbracketleft LEFT TORTOISE SHELL BRACKET 23 | 3015 tortoiseshellbracketright RIGHT TORTOISE SHELL BRACKET 24 | 3016 whitelenticularbracketleft LEFT WHITE LENTICULAR BRACKET 25 | 3017 whitelenticularbracketright RIGHT WHITE LENTICULAR BRACKET 26 | 3018 whitetortoiseshellbracketleft LEFT WHITE TORTOISE SHELL BRACKET 27 | 3019 whitetortoiseshellbracketright RIGHT WHITE TORTOISE SHELL BRACKET 28 | 301A whitesquarebracketleft LEFT WHITE SQUARE BRACKET 29 | 301B whitesquarebracketright RIGHT WHITE SQUARE BRACKET 30 | 301C wavedash WAVE DASH 31 | 301D quotedblprimereversed REVERSED DOUBLE PRIME QUOTATION MARK 32 | 301E quotedblprime DOUBLE PRIME QUOTATION MARK 33 | 301F lowquotedblprime LOW DOUBLE PRIME QUOTATION MARK 34 | 3020 postalmarkface POSTAL MARK FACE 35 | 3021 onehangzhou HANGZHOU NUMERAL ONE 36 | 3022 twohangzhou HANGZHOU NUMERAL TWO 37 | 3023 threehangzhou HANGZHOU NUMERAL THREE 38 | 3024 fourhangzhou HANGZHOU NUMERAL FOUR 39 | 3025 fivehangzhou HANGZHOU NUMERAL FIVE 40 | 3026 sixhangzhou HANGZHOU NUMERAL SIX 41 | 3027 sevenhangzhou HANGZHOU NUMERAL SEVEN 42 | 3028 eighthangzhou HANGZHOU NUMERAL EIGHT 43 | 3029 ninehangzhou HANGZHOU NUMERAL NINE 44 | 302A ideographicleveltonemark IDEOGRAPHIC LEVEL TONE MARK 45 | 302B ideographicrisingtonemark IDEOGRAPHIC RISING TONE MARK 46 | 302C ideographicdepartingtonemark IDEOGRAPHIC DEPARTING TONE MARK 47 | 302D ideographicenteringtonemark IDEOGRAPHIC ENTERING TONE MARK 48 | 302E hangulsingledottonemark HANGUL SINGLE DOT TONE MARK 49 | 302F hanguldottonemarkdbl HANGUL DOUBLE DOT TONE MARK 50 | 3030 wavydash WAVY DASH 51 | 3031 verticalkanarepeatmark VERTICAL KANA REPEAT MARK 52 | 3032 verticalkanarepeatwithvoicedsoundmark VERTICAL KANA REPEAT WITH VOICED SOUND MARK 53 | 3033 verticalkanarepeatmarkupperhalf VERTICAL KANA REPEAT MARK UPPER HALF 54 | 3034 verticalkanarepeatwithvoicedsoundmarkupperhalf VERTICAL KANA REPEAT WITH VOICED SOUND MARK UPPER HALF 55 | 3035 verticalkanarepeatmarklowerhalf VERTICAL KANA REPEAT MARK LOWER HALF 56 | 3036 circlepostalmark CIRCLED POSTAL MARK 57 | 3037 ideographictelegraphlinefeedseparatorsymbol IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL 58 | 3038 tenhangzhou HANGZHOU NUMERAL TEN 59 | 3039 twentyhangzhou HANGZHOU NUMERAL TWENTY 60 | 303A thirtyhangzhou HANGZHOU NUMERAL THIRTY 61 | 303B verticalideographiciterationmark VERTICAL IDEOGRAPHIC ITERATION MARK 62 | 303C masumark MASU MARK 63 | 303D partalternationmark PART ALTERNATION MARK 64 | 303E ideographicvariationindicator IDEOGRAPHIC VARIATION INDICATOR 65 | 303F ideographichalffillspace IDEOGRAPHIC HALF FILL SPACE -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/test/checkWhichArabicNamesHavePresentationForms.py: -------------------------------------------------------------------------------- 1 | # Using joiningtypes we can predict which connecting variants are needed for a specific 2 | # Arabic unicode. We can add the init, medi, fina extensions. Some of these new names 3 | # might also have their own, deprecated, presentation form unicode value. 4 | # Bahman advises to add these presentation form unicodes for legacy reasons. 5 | # Well, if we have the data, why not. 6 | # This script finds out which generateed variant names do not habe matching presentation form unicodes. 7 | # This should not be a problem - but if there are names that do have values, but perhaps 8 | # there is a naming mismatch that could be adjusted. 9 | 10 | import os 11 | from pprint import pprint 12 | from glyphNameFormatter.reader import * 13 | arabicRanges = [] 14 | for name in rangeNames: 15 | if "Ara" in name: 16 | arabicRanges.append(name) 17 | print(arabicRanges) 18 | 19 | def getAllNames(name): 20 | global joiningTypes 21 | # based on the category data, give suggestion for which extensions we need for any unicode 22 | extensions = { 23 | # XXXX no idea if it works this way... 24 | # D Dual_Joining 25 | # &----G----& 26 | 'D': ['init', 'medi', 'fina'], 27 | # C Join_Causing 28 | # &----G----& ???? 29 | 'C': [ ], 30 | # R Right_Joining 31 | # x G----& 32 | 'R': [ 'fina'], 33 | # L Left_Joining 34 | # &----G x 35 | 'L': ['init', 'fina'], 36 | # U Non_Joining 37 | # x G x 38 | 'U': [ ], 39 | # T Transparent 40 | # x G x 41 | 'T': [ ], 42 | } 43 | 44 | if joiningTypes is not None: 45 | variants = [name] 46 | uniValue = n2u(name) 47 | if uniValue is not None: 48 | ext = joiningTypes.get(uniValue) 49 | ext = extensions.get(ext) 50 | if ext: 51 | for e in ext: 52 | variants.append("%s.%s"%(name, e)) 53 | return variants 54 | 55 | def readJoiningTypes(path): 56 | # read the joiningTypes.txt 57 | joiningTypes = {} 58 | f = open(path, 'r') 59 | d = f.read() 60 | f.close() 61 | lines = d.split("\n") 62 | for l in lines: 63 | if not l: continue 64 | if l[0] == "#": continue 65 | parts = l.split("\t") 66 | uni = int('0x'+parts[0], 0) 67 | jT = parts[1] 68 | joiningTypes[uni] = jT 69 | return joiningTypes 70 | 71 | import glyphNameFormatter 72 | jTPath = os.path.join(os.path.dirname(glyphNameFormatter.__file__), "data", "joiningTypes.txt") 73 | joiningTypes = readJoiningTypes(jTPath) 74 | #print('joiningTypes', joiningTypes) 75 | 76 | noPresentationForms = {} 77 | for rangeName in arabicRanges: 78 | rangeMin, rangeMax = getRangeByName(rangeName) 79 | for num in range(rangeMin, rangeMax): 80 | name = u2n(num) 81 | allNames = getAllNames(name) 82 | show = False 83 | for variantName in allNames: 84 | variantUniValue = n2u(variantName) 85 | if variantUniValue is None: 86 | if variantName is None: 87 | continue 88 | if not show: 89 | show = True 90 | noPresentationForms[hex(num)] = allNames 91 | 92 | #print(len(noPresentationForms), "connecting variants without presentation forms according to our list.") 93 | 94 | print("these univalues + names have no presentation form unicode values") 95 | pprint(noPresentationForms) -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/01DC0-01DFF combining_diacritical_marks_supplement.txt: -------------------------------------------------------------------------------- 1 | # Combining Diacritical Marks Supplement 01DC0 - 01DFF 2 | 1DC0 dottedgravecmb COMBINING DOTTED GRAVE ACCENT 3 | 1DC1 dottedacutecmb COMBINING DOTTED ACUTE ACCENT 4 | 1DC2 snakebelowcmb COMBINING SNAKE BELOW 5 | 1DC3 suspensionmarkcmb COMBINING SUSPENSION MARK 6 | 1DC4 macronacutecmb COMBINING MACRON-ACUTE 7 | 1DC5 gravemacroncmb COMBINING GRAVE-MACRON 8 | 1DC6 macrongravecmb COMBINING MACRON-GRAVE 9 | 1DC7 acutemacroncmb COMBINING ACUTE-MACRON 10 | 1DC8 graveacutegravecmb COMBINING GRAVE-ACUTE-GRAVE 11 | 1DC9 acutegraveacutecmb COMBINING ACUTE-GRAVE-ACUTE 12 | 1DCA rbelowcmb COMBINING LATIN SMALL LETTER R BELOW 13 | 1DCB brevemacroncmb COMBINING BREVE-MACRON 14 | 1DCC macronbrevecmb COMBINING MACRON-BREVE 15 | 1DCD doubleabovecircumflexcmb COMBINING DOUBLE CIRCUMFLEX ABOVE 16 | 1DCE aboveogonekcmb COMBINING OGONEK ABOVE 17 | 1DCF zigzagbelowcmb COMBINING ZIGZAG BELOW 18 | 1DD0 isbelowcmb COMBINING IS BELOW 19 | 1DD1 urabovecmb COMBINING UR ABOVE 20 | 1DD2 usabovecmb COMBINING US ABOVE 21 | 1DD3 aaboveflatcmb COMBINING LATIN SMALL LETTER FLATTENED OPEN A ABOVE 22 | 1DD4 aecmb COMBINING LATIN SMALL LETTER AE 23 | 1DD5 aocmb COMBINING LATIN SMALL LETTER AO 24 | 1DD6 avcmb COMBINING LATIN SMALL LETTER AV 25 | 1DD7 ccedillacmb COMBINING LATIN SMALL LETTER C CEDILLA 26 | 1DD8 insulardcmb COMBINING LATIN SMALL LETTER INSULAR D 27 | 1DD9 ethcmb COMBINING LATIN SMALL LETTER ETH 28 | 1DDA gcmb COMBINING LATIN SMALL LETTER G 29 | 1DDB gsmallcmb COMBINING LATIN LETTER SMALL CAPITAL G 30 | 1DDC kcmb COMBINING LATIN SMALL LETTER K 31 | 1DDD lcmb COMBINING LATIN SMALL LETTER L 32 | 1DDE lsmallcmb COMBINING LATIN LETTER SMALL CAPITAL L 33 | 1DDF msmallcmb COMBINING LATIN LETTER SMALL CAPITAL M 34 | 1DE0 ncmb COMBINING LATIN SMALL LETTER N 35 | 1DE1 nsmallcmb COMBINING LATIN LETTER SMALL CAPITAL N 36 | 1DE2 rsmallcmb COMBINING LATIN LETTER SMALL CAPITAL R 37 | 1DE3 rrotundacmb COMBINING LATIN SMALL LETTER R ROTUNDA 38 | 1DE4 scmb COMBINING LATIN SMALL LETTER S 39 | 1DE5 longscmb COMBINING LATIN SMALL LETTER LONG S 40 | 1DE6 zcmb COMBINING LATIN SMALL LETTER Z 41 | 1DE7 alphacmb COMBINING LATIN SMALL LETTER ALPHA 42 | 1DE8 bcmb COMBINING LATIN SMALL LETTER B 43 | 1DE9 betacmb COMBINING LATIN SMALL LETTER BETA 44 | 1DEA schwacmb COMBINING LATIN SMALL LETTER SCHWA 45 | 1DEB fcmb COMBINING LATIN SMALL LETTER F 46 | 1DEC lwithdoublemiddletildecmb COMBINING LATIN SMALL LETTER L WITH DOUBLE MIDDLE TILDE 47 | 1DED owithlightcentralizationstrokecmb COMBINING LATIN SMALL LETTER O WITH LIGHT CENTRALIZATION STROKE 48 | 1DEE pcmb COMBINING LATIN SMALL LETTER P 49 | 1DEF eshcmb COMBINING LATIN SMALL LETTER ESH 50 | 1DF0 uwithlightcentralizationstrokecmb COMBINING LATIN SMALL LETTER U WITH LIGHT CENTRALIZATION STROKE 51 | 1DF1 wcmb COMBINING LATIN SMALL LETTER W 52 | 1DF2 adieresiscmb COMBINING LATIN SMALL LETTER A WITH DIAERESIS 53 | 1DF3 odieresiscmb COMBINING LATIN SMALL LETTER O WITH DIAERESIS 54 | 1DF4 udieresiscmb COMBINING LATIN SMALL LETTER U WITH DIAERESIS 55 | 1DF5 uptackabovecmb COMBINING UP TACK ABOVE 56 | 1DF6 kavykaaboverightcmb COMBINING KAVYKA ABOVE RIGHT 57 | 1DF7 kavykaaboveleftcmb COMBINING KAVYKA ABOVE LEFT 58 | 1DF8 dotaboveleftcmb COMBINING DOT ABOVE LEFT 59 | 1DF9 wideinvertedbridgebelowcmb COMBINING WIDE INVERTED BRIDGE BELOW 60 | 1DFA dotbelowleftcmb COMBINING DOT BELOW LEFT 61 | 1DFB deletionmarkcmb COMBINING DELETION MARK 62 | 1DFC doubleinvertedbelowbrevecmb COMBINING DOUBLE INVERTED BREVE BELOW 63 | 1DFD almostequaltobelowcmb COMBINING ALMOST EQUAL TO BELOW 64 | 1DFE leftarrowheadabovecmb COMBINING LEFT ARROWHEAD ABOVE 65 | 1DFF rightarrowheadanddownarrowheadbelowcmb COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/010A0-010FF georgian.txt: -------------------------------------------------------------------------------- 1 | # Georgian 010A0 - 010FF 2 | 10A0 AnGeok GEORGIAN CAPITAL LETTER AN 3 | 10A1 BanGeok GEORGIAN CAPITAL LETTER BAN 4 | 10A2 GanGeok GEORGIAN CAPITAL LETTER GAN 5 | 10A3 DonGeok GEORGIAN CAPITAL LETTER DON 6 | 10A4 EnGeok GEORGIAN CAPITAL LETTER EN 7 | 10A5 VinGeok GEORGIAN CAPITAL LETTER VIN 8 | 10A6 ZenGeok GEORGIAN CAPITAL LETTER ZEN 9 | 10A7 TanGeok GEORGIAN CAPITAL LETTER TAN 10 | 10A8 InGeok GEORGIAN CAPITAL LETTER IN 11 | 10A9 KanGeok GEORGIAN CAPITAL LETTER KAN 12 | 10AA LasGeok GEORGIAN CAPITAL LETTER LAS 13 | 10AB ManGeok GEORGIAN CAPITAL LETTER MAN 14 | 10AC NarGeok GEORGIAN CAPITAL LETTER NAR 15 | 10AD OnGeok GEORGIAN CAPITAL LETTER ON 16 | 10AE ParGeok GEORGIAN CAPITAL LETTER PAR 17 | 10AF ZharGeok GEORGIAN CAPITAL LETTER ZHAR 18 | 10B0 RaeGeok GEORGIAN CAPITAL LETTER RAE 19 | 10B1 SanGeok GEORGIAN CAPITAL LETTER SAN 20 | 10B2 TarGeok GEORGIAN CAPITAL LETTER TAR 21 | 10B3 UnGeok GEORGIAN CAPITAL LETTER UN 22 | 10B4 PharGeok GEORGIAN CAPITAL LETTER PHAR 23 | 10B5 KharGeok GEORGIAN CAPITAL LETTER KHAR 24 | 10B6 GhanGeok GEORGIAN CAPITAL LETTER GHAN 25 | 10B7 QarGeok GEORGIAN CAPITAL LETTER QAR 26 | 10B8 ShinGeok GEORGIAN CAPITAL LETTER SHIN 27 | 10B9 ChinGeok GEORGIAN CAPITAL LETTER CHIN 28 | 10BA CanGeok GEORGIAN CAPITAL LETTER CAN 29 | 10BB JilGeok GEORGIAN CAPITAL LETTER JIL 30 | 10BC CilGeok GEORGIAN CAPITAL LETTER CIL 31 | 10BD CharGeok GEORGIAN CAPITAL LETTER CHAR 32 | 10BE XanGeok GEORGIAN CAPITAL LETTER XAN 33 | 10BF JhanGeok GEORGIAN CAPITAL LETTER JHAN 34 | 10C0 HaeGeok GEORGIAN CAPITAL LETTER HAE 35 | 10C1 HeGeok GEORGIAN CAPITAL LETTER HE 36 | 10C2 HieGeok GEORGIAN CAPITAL LETTER HIE 37 | 10C3 WeGeok GEORGIAN CAPITAL LETTER WE 38 | 10C4 HarGeok GEORGIAN CAPITAL LETTER HAR 39 | 10C5 HoeGeok GEORGIAN CAPITAL LETTER HOE 40 | 10C7 YnGeok GEORGIAN CAPITAL LETTER YN 41 | 10CD AenGeok GEORGIAN CAPITAL LETTER AEN 42 | 10D0 anGeor GEORGIAN LETTER AN 43 | 10D1 banGeor GEORGIAN LETTER BAN 44 | 10D2 ganGeor GEORGIAN LETTER GAN 45 | 10D3 donGeor GEORGIAN LETTER DON 46 | 10D4 enGeor GEORGIAN LETTER EN 47 | 10D5 vinGeor GEORGIAN LETTER VIN 48 | 10D6 zenGeor GEORGIAN LETTER ZEN 49 | 10D7 tanGeor GEORGIAN LETTER TAN 50 | 10D8 inGeor GEORGIAN LETTER IN 51 | 10D9 kanGeor GEORGIAN LETTER KAN 52 | 10DA lasGeor GEORGIAN LETTER LAS 53 | 10DB manGeor GEORGIAN LETTER MAN 54 | 10DC narGeor GEORGIAN LETTER NAR 55 | 10DD onGeor GEORGIAN LETTER ON 56 | 10DE parGeor GEORGIAN LETTER PAR 57 | 10DF zharGeor GEORGIAN LETTER ZHAR 58 | 10E0 raeGeor GEORGIAN LETTER RAE 59 | 10E1 sanGeor GEORGIAN LETTER SAN 60 | 10E2 tarGeor GEORGIAN LETTER TAR 61 | 10E3 unGeor GEORGIAN LETTER UN 62 | 10E4 pharGeor GEORGIAN LETTER PHAR 63 | 10E5 kharGeor GEORGIAN LETTER KHAR 64 | 10E6 ghanGeor GEORGIAN LETTER GHAN 65 | 10E7 qarGeor GEORGIAN LETTER QAR 66 | 10E8 shinGeor GEORGIAN LETTER SHIN 67 | 10E9 chinGeor GEORGIAN LETTER CHIN 68 | 10EA canGeor GEORGIAN LETTER CAN 69 | 10EB jilGeor GEORGIAN LETTER JIL 70 | 10EC cilGeor GEORGIAN LETTER CIL 71 | 10ED charGeor GEORGIAN LETTER CHAR 72 | 10EE xanGeor GEORGIAN LETTER XAN 73 | 10EF jhanGeor GEORGIAN LETTER JHAN 74 | 10F0 haeGeor GEORGIAN LETTER HAE 75 | 10F1 heGeor GEORGIAN LETTER HE 76 | 10F2 hieGeor GEORGIAN LETTER HIE 77 | 10F3 weGeor GEORGIAN LETTER WE 78 | 10F4 harGeor GEORGIAN LETTER HAR 79 | 10F5 hoeGeor GEORGIAN LETTER HOE 80 | 10F6 fiGeor GEORGIAN LETTER FI 81 | 10F7 ynGeor GEORGIAN LETTER YN 82 | 10F8 elifiGeor GEORGIAN LETTER ELIFI 83 | 10F9 turnedganGeor GEORGIAN LETTER TURNED GAN 84 | 10FA ainGeor GEORGIAN LETTER AIN 85 | 10FB geor:paragraphseparator GEORGIAN PARAGRAPH SEPARATOR 86 | 10FC narmodGeor MODIFIER LETTER GEORGIAN NAR 87 | 10FD aenGeor GEORGIAN LETTER AEN 88 | 10FE hardsignGeor GEORGIAN LETTER HARD SIGN 89 | 10FF labialsignGeor GEORGIAN LETTER LABIAL SIGN -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/rangeProcessors/hebrew.py: -------------------------------------------------------------------------------- 1 | # Edited in March 2016 by Daniel Grumer 2 | # Spelling of Cantillation Marks were adjusted according to Wikipedia (https://en.wikipedia.org/wiki/Cantillation) 3 | 4 | 5 | def process(self): 6 | # Those are ligatures. They can be used for both Hebrew and Yiddish, no need for language indication. 7 | self.replace("HEBREW LIGATURE YIDDISH DOUBLE VAV", "vav_vav") 8 | self.replace("HEBREW LIGATURE YIDDISH VAV YOD", "vav_yod") 9 | self.replace("HEBREW LIGATURE YIDDISH DOUBLE YOD", "yod_yod") 10 | 11 | # This is a change that was not created by me, but seems totally fine. I also have no idea what those marks are used for (will try to find out) 12 | self.replace("HEBREW MARK UPPER DOT", "dotupper") 13 | self.replace("HEBREW MARK LOWER DOT", "dotlower") 14 | 15 | # Those are changes in spelling, to match the Ashkenazi naming as they appear in Wikipedia: 16 | self.edit("ATNAH HAFUKH", "atnachHafukh") 17 | self.edit("MUNAH", "munach") 18 | self.edit("MAHAPAKH", "mahpach") 19 | self.edit("MERKHA KEFULA", "merchaKefulah") 20 | self.edit("MERKHA", "mercha") 21 | self.edit("QARNEY PARA", "qarneFarah") 22 | self.edit("TELISHA GEDOLA", "telishaGedolah") 23 | self.edit("TELISHA QETANA", "telishaQetannah") 24 | self.edit("TIPEHA", "tifcha") 25 | self.edit("YERAH BEN YOMO", "yerachBenYomo") 26 | self.edit("ZINOR", "tsinnorit") 27 | self.edit("HOLAM HASER FOR VAV", "holamHaser") 28 | self.edit("DAGESH OR MAPIQ", "dagesh") 29 | self.edit("MARK MASORA CIRCLE", "masoraCircle") 30 | 31 | # Those are just adding the word-separation 32 | self.edit("GERESH MUQDAM", "gereshMuqdam") 33 | self.edit("ZAQEF QATAN", "zaqefQatan") 34 | self.edit("ZAQEF GADOL", "zaqefGadol") 35 | self.edit("SOF PASUQ", "sofPasuq") 36 | self.edit("HATAF SEGOL", "hatafSegol") 37 | self.edit("HATAF PATAH", "hatafPatah") 38 | self.edit("HATAF QAMATS", "hatafQamats") 39 | self.edit("SIN DOT", "sinDot") 40 | self.edit("SHIN DOT", "shinDot") 41 | self.edit("NUN HAFUKHA", "nunHafukha") 42 | self.edit("QAMATS QATAN", "qamatsQatan") 43 | 44 | # avoid multiple names 45 | self.edit("ACCENT SEGOL", "segolta") # different name chosen to avoid multiples 46 | self.edit("ACCENT GERSHAYIM", "SheneGerishin") # different name chosen to avoid multiples 47 | self.edit("ACCENT GERESH", "azla" ) # different name chosen to avoid multiples 48 | 49 | # used in alphabetic presentation forms 50 | self.edit("WIDE", "wide") 51 | self.edit("JUDEO-SPANISH", 'judeospanish') 52 | self.edit("HEBREW LIGATURE YIDDISH YOD YOD PATAH", "yod_yod_patah") 53 | self.edit("ALTERNATIVE", "alt") 54 | 55 | # cleanup 56 | self.edit("POINT") # 'Nikud' marks Vowel-pointing system 57 | self.edit("ACCENT") # Cantillation marks Used in religious texts, to indicate how to sing 58 | self.edit("PUNCTUATION") # Puncutation marks Used in religious texts (regular texts use the latin period, comma, colon etc) 59 | self.edit("MARK") # Other marks I couldn't find what they are used for 60 | 61 | if self.has("YIDDISH"): 62 | if self.replace("YIDDISH"): 63 | self.suffix("yiddish") 64 | if self.has("PUNCTUATION"): 65 | self.replace("PUNCTUATION") 66 | 67 | self.edit("HEBREW LETTER") 68 | self.edit('HEBREW') 69 | self.edit("LETTER") 70 | self.lower() 71 | self.compress() 72 | self.scriptPrefix() 73 | 74 | if __name__ == "__main__": 75 | from glyphNameFormatter.exporters import printRange 76 | printRange("Hebrew") 77 | -------------------------------------------------------------------------------- /Lib/glyphNameFormatter/names/ranges/00E00-00E7F thai.txt: -------------------------------------------------------------------------------- 1 | # Thai 00E00 - 00E7F 2 | 0E01 th:kokai THAI CHARACTER KO KAI 3 | 0E02 th:khokhai THAI CHARACTER KHO KHAI 4 | 0E03 th:khokhuat THAI CHARACTER KHO KHUAT 5 | 0E04 th:khokhwai THAI CHARACTER KHO KHWAI 6 | 0E05 th:khokhon THAI CHARACTER KHO KHON 7 | 0E06 th:khorakhang THAI CHARACTER KHO RAKHANG 8 | 0E07 th:ngongu THAI CHARACTER NGO NGU 9 | 0E08 th:chochan THAI CHARACTER CHO CHAN 10 | 0E09 th:choching THAI CHARACTER CHO CHING 11 | 0E0A th:chochang THAI CHARACTER CHO CHANG 12 | 0E0B th:soso THAI CHARACTER SO SO 13 | 0E0C th:chochoe THAI CHARACTER CHO CHOE 14 | 0E0D th:yoying THAI CHARACTER YO YING 15 | 0E0E th:dochada THAI CHARACTER DO CHADA 16 | 0E0F th:topatak THAI CHARACTER TO PATAK 17 | 0E10 th:thothan THAI CHARACTER THO THAN 18 | 0E11 th:thonangmontho THAI CHARACTER THO NANGMONTHO 19 | 0E12 th:thophuthao THAI CHARACTER THO PHUTHAO 20 | 0E13 th:nonen THAI CHARACTER NO NEN 21 | 0E14 th:dodek THAI CHARACTER DO DEK 22 | 0E15 th:totao THAI CHARACTER TO TAO 23 | 0E16 th:thothung THAI CHARACTER THO THUNG 24 | 0E17 th:thothahan THAI CHARACTER THO THAHAN 25 | 0E18 th:thothong THAI CHARACTER THO THONG 26 | 0E19 th:nonu THAI CHARACTER NO NU 27 | 0E1A th:bobaimai THAI CHARACTER BO BAIMAI 28 | 0E1B th:popla THAI CHARACTER PO PLA 29 | 0E1C th:phophung THAI CHARACTER PHO PHUNG 30 | 0E1D th:fofa THAI CHARACTER FO FA 31 | 0E1E th:phophan THAI CHARACTER PHO PHAN 32 | 0E1F th:fofan THAI CHARACTER FO FAN 33 | 0E20 th:phosamphao THAI CHARACTER PHO SAMPHAO 34 | 0E21 th:moma THAI CHARACTER MO MA 35 | 0E22 th:yoyak THAI CHARACTER YO YAK 36 | 0E23 th:rorua THAI CHARACTER RO RUA 37 | 0E24 th:ru THAI CHARACTER RU 38 | 0E25 th:loling THAI CHARACTER LO LING 39 | 0E26 th:lu THAI CHARACTER LU 40 | 0E27 th:wowaen THAI CHARACTER WO WAEN 41 | 0E28 th:sosala THAI CHARACTER SO SALA 42 | 0E29 th:sorusi THAI CHARACTER SO RUSI 43 | 0E2A th:sosua THAI CHARACTER SO SUA 44 | 0E2B th:hohip THAI CHARACTER HO HIP 45 | 0E2C th:lochula THAI CHARACTER LO CHULA 46 | 0E2D th:oang THAI CHARACTER O ANG 47 | 0E2E th:honokhuk THAI CHARACTER HO NOKHUK 48 | 0E2F th:paiyannoi THAI CHARACTER PAIYANNOI 49 | 0E30 th:saraa THAI CHARACTER SARA A 50 | 0E31 th:maihan-akat THAI CHARACTER MAI HAN-AKAT 51 | 0E32 th:saraaa THAI CHARACTER SARA AA 52 | 0E33 th:saraam THAI CHARACTER SARA AM 53 | 0E34 th:sarai THAI CHARACTER SARA I 54 | 0E35 th:saraii THAI CHARACTER SARA II 55 | 0E36 th:saraue THAI CHARACTER SARA UE 56 | 0E37 th:sarauee THAI CHARACTER SARA UEE 57 | 0E38 th:sarau THAI CHARACTER SARA U 58 | 0E39 th:sarauu THAI CHARACTER SARA UU 59 | 0E3A th:phinthu THAI CHARACTER PHINTHU 60 | 0E3F th:baht THAI CURRENCY SYMBOL BAHT 61 | 0E40 th:sarae THAI CHARACTER SARA E 62 | 0E41 th:saraae THAI CHARACTER SARA AE 63 | 0E42 th:sarao THAI CHARACTER SARA O 64 | 0E43 th:saraaimaimuan THAI CHARACTER SARA AI MAIMUAN 65 | 0E44 th:saraaimaimalai THAI CHARACTER SARA AI MAIMALAI 66 | 0E45 th:lakkhangyao THAI CHARACTER LAKKHANGYAO 67 | 0E46 th:maiyamok THAI CHARACTER MAIYAMOK 68 | 0E47 th:maitaikhu THAI CHARACTER MAITAIKHU 69 | 0E48 th:maiek THAI CHARACTER MAI EK 70 | 0E49 th:maitho THAI CHARACTER MAI THO 71 | 0E4A th:maitri THAI CHARACTER MAI TRI 72 | 0E4B th:maichattawa THAI CHARACTER MAI CHATTAWA 73 | 0E4C th:thanthakhat THAI CHARACTER THANTHAKHAT 74 | 0E4D th:nikhahit THAI CHARACTER NIKHAHIT 75 | 0E4E th:yamakkan THAI CHARACTER YAMAKKAN 76 | 0E4F th:fongman THAI CHARACTER FONGMAN 77 | 0E50 th:zero THAI DIGIT ZERO 78 | 0E51 th:one THAI DIGIT ONE 79 | 0E52 th:two THAI DIGIT TWO 80 | 0E53 th:three THAI DIGIT THREE 81 | 0E54 th:four THAI DIGIT FOUR 82 | 0E55 th:five THAI DIGIT FIVE 83 | 0E56 th:six THAI DIGIT SIX 84 | 0E57 th:seven THAI DIGIT SEVEN 85 | 0E58 th:eight THAI DIGIT EIGHT 86 | 0E59 th:nine THAI DIGIT NINE 87 | 0E5A th:angkhankhu THAI CHARACTER ANGKHANKHU 88 | 0E5B th:khomut THAI CHARACTER KHOMUT --------------------------------------------------------------------------------