Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

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

# -*- coding: utf-8 -*- 

""" 

    pygments.style 

    ~~~~~~~~~~~~~~ 

 

    Basic style object. 

 

    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS. 

    :license: BSD, see LICENSE for details. 

""" 

 

from pygments.token import Token, STANDARD_TYPES 

from pygments.util import add_metaclass 

 

 

class StyleMeta(type): 

 

    def __new__(mcs, name, bases, dct): 

        obj = type.__new__(mcs, name, bases, dct) 

        for token in STANDARD_TYPES: 

            if token not in obj.styles: 

                obj.styles[token] = '' 

 

        def colorformat(text): 

            if text[0:1] == '#': 

                col = text[1:] 

                if len(col) == 6: 

                    return col 

                elif len(col) == 3: 

                    return col[0]*2 + col[1]*2 + col[2]*2 

            elif text == '': 

                return '' 

            assert False, "wrong color format %r" % text 

 

        _styles = obj._styles = {} 

 

        for ttype in obj.styles: 

            for token in ttype.split(): 

                if token in _styles: 

                    continue 

                ndef = _styles.get(token.parent, None) 

                styledefs = obj.styles.get(token, '').split() 

                if  not ndef or token is None: 

                    ndef = ['', 0, 0, 0, '', '', 0, 0, 0] 

                elif 'noinherit' in styledefs and token is not Token: 

                    ndef = _styles[Token][:] 

                else: 

                    ndef = ndef[:] 

                _styles[token] = ndef 

                for styledef in obj.styles.get(token, '').split(): 

                    if styledef == 'noinherit': 

                        pass 

                    elif styledef == 'bold': 

                        ndef[1] = 1 

                    elif styledef == 'nobold': 

                        ndef[1] = 0 

                    elif styledef == 'italic': 

                        ndef[2] = 1 

                    elif styledef == 'noitalic': 

                        ndef[2] = 0 

                    elif styledef == 'underline': 

                        ndef[3] = 1 

                    elif styledef == 'nounderline': 

                        ndef[3] = 0 

                    elif styledef[:3] == 'bg:': 

                        ndef[4] = colorformat(styledef[3:]) 

                    elif styledef[:7] == 'border:': 

                        ndef[5] = colorformat(styledef[7:]) 

                    elif styledef == 'roman': 

                        ndef[6] = 1 

                    elif styledef == 'sans': 

                        ndef[7] = 1 

                    elif styledef == 'mono': 

                        ndef[8] = 1 

                    else: 

                        ndef[0] = colorformat(styledef) 

 

        return obj 

 

    def style_for_token(cls, token): 

        t = cls._styles[token] 

        return { 

            'color':        t[0] or None, 

            'bold':         bool(t[1]), 

            'italic':       bool(t[2]), 

            'underline':    bool(t[3]), 

            'bgcolor':      t[4] or None, 

            'border':       t[5] or None, 

            'roman':        bool(t[6]) or None, 

            'sans':         bool(t[7]) or None, 

            'mono':         bool(t[8]) or None, 

        } 

 

    def list_styles(cls): 

        return list(cls) 

 

    def styles_token(cls, ttype): 

        return ttype in cls._styles 

 

    def __iter__(cls): 

        for token in cls._styles: 

            yield token, cls.style_for_token(token) 

 

    def __len__(cls): 

        return len(cls._styles) 

 

 

@add_metaclass(StyleMeta) 

class Style(object): 

 

    #: overall background color (``None`` means transparent) 

    background_color = '#ffffff' 

 

    #: highlight background color 

    highlight_color = '#ffffcc' 

 

    #: Style definitions for individual token types. 

    styles = {}