FilesExpand file tree

 transforms

/

fontconfig_pattern.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

170 lines (143 loc) · 5.83 KB

 transforms

/

fontconfig_pattern.py

Copy path

Top

File metadata and controls

• Code
• Blame

170 lines (143 loc) · 5.83 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

"""

A module for parsing a fontconfig pattern.

This class is defined here because it must be available in:

- The old-style config framework (rcsetup.py)

- The traits-based config framework (mpltraits.py)

- The font manager (font_manager.py)

It probably logically belongs in font_manager.py, but

placing it in any of these places would have created cyclical

dependency problems, or an undesired dependency on traits even

when the traits-based config framework is not used.

See here for a rough specification of these patterns:

http://www.fontconfig.org/fontconfig-user.html

Author : Michael Droettboom <mdroe@stsci.edu>

License : matplotlib license (PSF compatible)

"""

import re

from matplotlib.pyparsing import Literal, ZeroOrMore, \

Optional, Regex, StringEnd, ParseException, Suppress

family_punc = r'\\\-:,'

family_unescape = re.compile(r'\\([%s])' % family_punc).sub

family_escape = re.compile(r'([%s])' % family_punc).sub

value_punc = r'\\=_:,'

value_unescape = re.compile(r'\\([%s])' % value_punc).sub

value_escape = re.compile(r'([%s])' % value_punc).sub

class FontconfigPatternParser:

"""A simple pyparsing-based parser for fontconfig-style patterns.

See here for a rough specification of these patterns:

http://www.fontconfig.org/fontconfig-user.html

"""

_constants = {

'thin' : ('weight', 'light'),

'extralight' : ('weight', 'light'),

'ultralight' : ('weight', 'light'),

'light' : ('weight', 'light'),

'book' : ('weight', 'book'),

'regular' : ('weight', 'regular'),

'normal' : ('weight', 'normal'),

'medium' : ('weight', 'medium'),

'demibold' : ('weight', 'demibold'),

'semibold' : ('weight', 'semibold'),

'bold' : ('weight', 'bold'),

'extrabold' : ('weight', 'extra bold'),

'black' : ('weight', 'black'),

'heavy' : ('weight', 'heavy'),

'roman' : ('slant', 'normal'),

'italic' : ('slant', 'italic'),

'oblique' : ('slant', 'oblique'),

'ultracondensed' : ('width', 'ultra-condensed'),

'extracondensed' : ('width', 'extra-condensed'),

'condensed' : ('width', 'condensed'),

'semicondensed' : ('width', 'semi-condensed'),

'expanded' : ('width', 'expanded'),

'extraexpanded' : ('width', 'extra-expanded'),

'ultraexpanded' : ('width', 'ultra-expanded')

}

def __init__(self):

family = Regex(r'([^%s]|(\\[%s]))*' %

(family_punc, family_punc)) \

.setParseAction(self._family)

size = Regex(r'[0-9.]+') \

.setParseAction(self._size)

name = Regex(r'[a-z]+') \

.setParseAction(self._name)

value = Regex(r'([^%s]|(\\[%s]))*' %

(value_punc, value_punc)) \

.setParseAction(self._value)

families =(family

+ ZeroOrMore(

Literal(',')

+ family)

).setParseAction(self._families)

point_sizes =(size

+ ZeroOrMore(

Literal(',')

+ size)

).setParseAction(self._point_sizes)

property =( (name

+ Suppress(Literal('='))

+ value

+ ZeroOrMore(

Suppress(Literal(','))

+ value)

)

| name

).setParseAction(self._property)

pattern =(Optional(

families)

+ Optional(

Literal('-')

+ point_sizes)

+ ZeroOrMore(

Literal(':')

+ property)

+ StringEnd()

)

self._parser = pattern

self.ParseException = ParseException

def parse(self, pattern):

props = self._properties = {}

try:

self._parser.parseString(pattern)

except self.ParseException, e:

raise ValueError("Could not parse font string: '%s'\n%s" % (pattern, e))

self._properties = None

return props

def _family(self, s, loc, tokens):

return [family_unescape(r'\1', tokens[0])]

def _size(self, s, loc, tokens):

return [float(tokens[0])]

def _name(self, s, loc, tokens):

return [tokens[0]]

def _value(self, s, loc, tokens):

return [value_unescape(r'\1', tokens[0])]

def _families(self, s, loc, tokens):

self._properties['family'] = tokens

return []

def _point_sizes(self, s, loc, tokens):

self._properties['size'] = tokens

return []

def _property(self, s, loc, tokens):

if len(tokens) == 1:

if tokens[0] in self._constants:

key, val = self._constants[tokens[0]]

self._properties.setdefault(key, []).append(val)

else:

key = tokens[0]

val = tokens[1:]

self._properties.setdefault(key, []).extend(val)

return []

parse_fontconfig_pattern = FontconfigPatternParser().parse

def generate_fontconfig_pattern(d):

"""Given a dictionary of key/value pairs, generates a fontconfig pattern

string."""

props = []

families = ''

size = ''

for key, val in d.items():

if val is not None and val != []:

val = [value_escape(r'\\\1', str(x)) for x in val if x is not None]

if val != []:

val = ','.join(val)

props.append(":%s=%s" % (key, val))

return ''.join(props)