Kivy-examples 2.3.1.dev0__py3-none-any.whl

kivy/lang/parser.py

@@ -0,0 +1,822 @@
+'''
+Parser
+======
+
+Class used for the parsing of .kv files into rules.
+'''
+import os
+
+import re
+import sys
+import traceback
+import ast
+import importlib
+from re import sub, findall
+from types import CodeType
+from functools import partial
+from collections import OrderedDict, defaultdict
+
+import kivy.lang.builder  # imported as absolute to avoid circular import
+from kivy.logger import Logger
+from kivy.cache import Cache
+from kivy import require
+from kivy.resources import resource_find
+from kivy.utils import rgba
+import kivy.metrics as Metrics
+
+__all__ = ('Parser', 'ParserException')
+
+
+trace = Logger.trace
+global_idmap = {}
+
+# register cache for creating new classtype (template)
+Cache.register('kv.lang')
+
+# all previously included files
+__KV_INCLUDES__ = []
+
+# precompile regexp expression
+str_re = (
+    "(?:'''.*?''')|"
+    "(?:(?:(?<!')|''')'(?:[^']|\\\\')+?'(?:(?!')|'''))|"
+    '(?:""".*?""")|'
+    '(?:(?:(?<!")|""")"(?:[^"]|\\\\")+?"(?:(?!")|"""))'
+)
+
+lang_str = re.compile(f"({str_re})", re.DOTALL)
+lang_fstr = re.compile(f"([fF](?:{str_re}))", re.DOTALL)
+
+lang_key = re.compile('([a-zA-Z_]+)')
+lang_keyvalue = re.compile(r'([a-zA-Z_][a-zA-Z0-9_.]*\.[a-zA-Z0-9_.]+)')
+lang_tr = re.compile(r'(_\()')
+lang_cls_split_pat = re.compile(', *')
+
+# all the widget handlers, used to correctly unbind all the callbacks then the
+# widget is deleted
+_handlers = defaultdict(partial(defaultdict, list))
+
+
+class ProxyApp(object):
+    # proxy app object
+    # taken from http://code.activestate.com/recipes/496741-object-proxying/
+
+    __slots__ = ['_obj']
+
+    def __init__(self):
+        object.__init__(self)
+        object.__setattr__(self, '_obj', None)
+
+    def _ensure_app(self):
+        app = object.__getattribute__(self, '_obj')
+        if app is None:
+            from kivy.app import App
+            app = App.get_running_app()
+            object.__setattr__(self, '_obj', app)
+            # Clear cached application instance, when it stops
+            app.bind(on_stop=lambda instance:
+                     object.__setattr__(self, '_obj', None))
+        return app
+
+    def __getattribute__(self, name):
+        object.__getattribute__(self, '_ensure_app')()
+        return getattr(object.__getattribute__(self, '_obj'), name)
+
+    def __delattr__(self, name):
+        object.__getattribute__(self, '_ensure_app')()
+        delattr(object.__getattribute__(self, '_obj'), name)
+
+    def __setattr__(self, name, value):
+        object.__getattribute__(self, '_ensure_app')()
+        setattr(object.__getattribute__(self, '_obj'), name, value)
+
+    def __bool__(self):
+        object.__getattribute__(self, '_ensure_app')()
+        return bool(object.__getattribute__(self, '_obj'))
+
+    def __str__(self):
+        object.__getattribute__(self, '_ensure_app')()
+        return str(object.__getattribute__(self, '_obj'))
+
+    def __repr__(self):
+        object.__getattribute__(self, '_ensure_app')()
+        return repr(object.__getattribute__(self, '_obj'))
+
+
+global_idmap['app'] = ProxyApp()
+global_idmap['pt'] = Metrics.pt
+global_idmap['inch'] = Metrics.inch
+global_idmap['cm'] = Metrics.cm
+global_idmap['mm'] = Metrics.mm
+global_idmap['dp'] = Metrics.dp
+global_idmap['sp'] = Metrics.sp
+global_idmap['rgba'] = rgba
+
+
+class ParserException(Exception):
+    '''Exception raised when something wrong happened in a kv file.
+    '''
+
+    def __init__(self, context, line, message, cause=None):
+        self.filename = context.filename or '<inline>'
+        self.line = line
+        sourcecode = context.sourcecode
+        sc_start = max(0, line - 2)
+        sc_stop = min(len(sourcecode), line + 3)
+        sc = ['...']
+        for x in range(sc_start, sc_stop):
+            if x == line:
+                sc += ['>> %4d:%s' % (line + 1, sourcecode[line][1])]
+            else:
+                sc += ['   %4d:%s' % (x + 1, sourcecode[x][1])]
+        sc += ['...']
+        sc = '\n'.join(sc)
+
+        message = 'Parser: File "%s", line %d:\n%s\n%s' % (
+            self.filename, self.line + 1, sc, message)
+        if cause:
+            message += '\n' + ''.join(traceback.format_tb(cause))
+
+        super(ParserException, self).__init__(message)
+
+
+class ParserRuleProperty(object):
+    '''Represent a property inside a rule.
+    '''
+
+    __slots__ = ('ctx', 'line', 'name', 'value', 'co_value',
+                 'watched_keys', 'mode', 'count', 'ignore_prev')
+
+    def __init__(self, ctx, line, name, value, ignore_prev=False):
+        super(ParserRuleProperty, self).__init__()
+        #: Associated parser
+        self.ctx = ctx
+        #: Line of the rule
+        self.line = line
+        #: Name of the property
+        self.name = name
+        #: Value of the property
+        self.value = value
+        #: Compiled value
+        self.co_value = None
+        #: Compilation mode
+        self.mode = None
+        #: Watched keys
+        self.watched_keys = None
+        #: Stats
+        self.count = 0
+        #: whether previous rules targeting name should be cleared
+        self.ignore_prev = ignore_prev
+
+    def precompile(self):
+        name = self.name
+        value = self.value
+
+        # first, remove all the string from the value
+        tmp = sub(lang_str, '', self.value)
+
+        # detecting how to handle the value according to the key name
+        mode = self.mode
+        if self.mode is None:
+            self.mode = mode = 'exec' if name[:3] == 'on_' else 'eval'
+        if mode == 'eval':
+            # if we don't detect any string/key in it, we can eval and give the
+            # result
+            if re.search(lang_key, tmp) is None:
+                value = '\n' * self.line + value
+                self.co_value = eval(
+                    compile(value, self.ctx.filename or '<string>', 'eval')
+                )
+                return
+
+        # ok, we can compile.
+        value = '\n' * self.line + value
+        self.co_value = compile(value, self.ctx.filename or '<string>', mode)
+
+        # for exec mode, we don't need to watch any keys.
+        if mode == 'exec':
+            return
+
+        # now, detect obj.prop
+        # find all the fstrings in the  value
+        fstrings = lang_fstr.findall(value)
+        wk = set()
+        for s in fstrings:
+            expression = ast.parse(s)
+            wk |= set(self.get_names_from_expression(expression.body[0].value))
+
+        # first, remove all the string from the value
+        tmp = sub(lang_str, '', value)
+        idx = tmp.find('#')
+        if idx != -1:
+            tmp = tmp[:idx]
+        # detect key.value inside value, and split them
+        wk |= set(findall(lang_keyvalue, tmp))
+        if wk:
+            self.watched_keys = [x.split('.') for x in wk]
+        if findall(lang_tr, tmp):
+            if self.watched_keys:
+                self.watched_keys += [['_']]
+            else:
+                self.watched_keys = [['_']]
+
+    @classmethod
+    def get_names_from_expression(cls, node):
+        """
+        Look for all the symbols used in an ast node.
+        """
+        if isinstance(node, ast.Name):
+            yield node.id
+
+        if isinstance(node, (ast.JoinedStr, ast.BoolOp)):
+            for n in node.values:
+                if isinstance(n, ast.Str):
+                    # NOTE: required for python3.6
+                    yield from cls.get_names_from_expression(n.s)
+                else:
+                    yield from cls.get_names_from_expression(n.value)
+
+        if isinstance(node, ast.BinOp):
+            yield from cls.get_names_from_expression(node.right)
+            yield from cls.get_names_from_expression(node.left)
+
+        if isinstance(node, ast.IfExp):
+            yield from cls.get_names_from_expression(node.test)
+            yield from cls.get_names_from_expression(node.body)
+            yield from cls.get_names_from_expression(node.orelse)
+
+        if isinstance(node, ast.Subscript):
+            yield from cls.get_names_from_expression(node.value)
+            yield from cls.get_names_from_expression(node.slice)
+
+        if isinstance(node, ast.Slice):
+            yield from cls.get_names_from_expression(node.lower)
+            yield from cls.get_names_from_expression(node.upper)
+            yield from cls.get_names_from_expression(node.step)
+
+        if isinstance(
+            node,
+            (ast.ListComp, ast.DictComp, ast.SetComp, ast.GeneratorExp)
+        ):
+            for g in node.generators:
+                yield from cls.get_names_from_expression(g.iter)
+
+        if isinstance(node, (ast.List, ast.Tuple, ast.Set)):
+            for elt in node.elts:
+                yield from cls.get_names_from_expression(elt)
+
+        if isinstance(node, ast.Dict):
+            for val in node.values:
+                yield from cls.get_names_from_expression(val)
+
+        if isinstance(node, ast.UnaryOp):
+            yield from cls.get_names_from_expression(node.operand)
+
+        if isinstance(node, ast.comprehension):
+            yield from cls.get_names_from_expression(node.iter.value)
+
+        if isinstance(node, ast.Attribute):
+            if isinstance(node.value, ast.Name):
+                yield f'{node.value.id}.{node.attr}'
+
+        if isinstance(node, ast.Call):
+            yield from cls.get_names_from_expression(node.func)
+
+            for arg in node.args:
+                yield from cls.get_names_from_expression(arg)
+            for keyword in node.keywords:
+                yield from cls.get_names_from_expression(keyword.value)
+
+    def __repr__(self):
+        return '<ParserRuleProperty name=%r filename=%s:%d ' \
+               'value=%r watched_keys=%r>' % (
+                   self.name, self.ctx.filename, self.line + 1,
+                   self.value, self.watched_keys)
+
+
+class ParserRule(object):
+    '''Represents a rule, in terms of the Kivy internal language.
+    '''
+
+    __slots__ = ('ctx', 'line', 'name', 'children', 'id', 'properties',
+                 'canvas_before', 'canvas_root', 'canvas_after',
+                 'handlers', 'level', 'cache_marked', 'avoid_previous_rules')
+
+    def __init__(self, ctx, line, name, level):
+        super(ParserRule, self).__init__()
+        #: Level of the rule in the kv
+        self.level = level
+        #: Associated parser
+        self.ctx = ctx
+        #: Line of the rule
+        self.line = line
+        #: Name of the rule
+        self.name = name
+        #: List of children to create
+        self.children = []
+        #: Id given to the rule
+        self.id = None
+        #: Properties associated to the rule
+        self.properties = OrderedDict()
+        #: Canvas normal
+        self.canvas_root = None
+        #: Canvas before
+        self.canvas_before = None
+        #: Canvas after
+        self.canvas_after = None
+        #: Handlers associated to the rule
+        self.handlers = []
+        #: Properties cache list: mark which class have already been checked
+        self.cache_marked = []
+        #: Indicate if any previous rules should be avoided.
+        self.avoid_previous_rules = False
+
+        if level == 0:
+            self._detect_selectors()
+        else:
+            self._forbid_selectors()
+
+    def precompile(self):
+        for x in self.properties.values():
+            x.precompile()
+        for x in self.handlers:
+            x.precompile()
+        for x in self.children:
+            x.precompile()
+        if self.canvas_before:
+            self.canvas_before.precompile()
+        if self.canvas_root:
+            self.canvas_root.precompile()
+        if self.canvas_after:
+            self.canvas_after.precompile()
+
+    def create_missing(self, widget):
+        # check first if the widget class already been processed by this rule
+        cls = widget.__class__
+        if cls in self.cache_marked:
+            return
+        self.cache_marked.append(cls)
+        for name in self.properties:
+            if hasattr(widget, name):
+                continue
+            value = self.properties[name].co_value
+            if type(value) is CodeType:
+                value = None
+            widget.create_property(name, value, default_value=False)
+
+    def _forbid_selectors(self):
+        c = self.name[0]
+        if c == '<' or c == '[':
+            raise ParserException(
+                self.ctx, self.line,
+                'Selectors rules are allowed only at the first level')
+
+    def _detect_selectors(self):
+        c = self.name[0]
+        if c == '<':
+            self._build_rule()
+        elif c == '[':
+            self._build_template()
+        else:
+            if self.ctx.root is not None:
+                raise ParserException(
+                    self.ctx, self.line,
+                    'Only one root object is allowed by .kv')
+            self.ctx.root = self
+
+    def _build_rule(self):
+        name = self.name
+        if __debug__:
+            trace('Builder: build rule for %s' % name)
+        if name[0] != '<' or name[-1] != '>':
+            raise ParserException(self.ctx, self.line,
+                                  'Invalid rule (must be inside <>)')
+
+        # if the very first name start with a -, avoid previous rules
+        name = name[1:-1]
+        if name[:1] == '-':
+            self.avoid_previous_rules = True
+            name = name[1:]
+
+        for rule in re.split(lang_cls_split_pat, name):
+            crule = None
+
+            if not rule:
+                raise ParserException(self.ctx, self.line,
+                                      'Empty rule detected')
+
+            if '@' in rule:
+                # new class creation ?
+                # ensure the name is correctly written
+                rule, baseclasses = rule.split('@', 1)
+                if not re.match(lang_key, rule):
+                    raise ParserException(self.ctx, self.line,
+                                          'Invalid dynamic class name')
+
+                # save the name in the dynamic classes dict.
+                self.ctx.dynamic_classes[rule] = baseclasses
+                crule = ParserSelectorName(rule)
+
+            else:
+                # classical selectors.
+
+                if rule[0] == '.':
+                    crule = ParserSelectorClass(rule[1:])
+                else:
+                    crule = ParserSelectorName(rule)
+
+            self.ctx.rules.append((crule, self))
+
+    def _build_template(self):
+        name = self.name
+        exception = ParserException(
+            self.ctx, self.line,
+            'Deprecated Kivy lang template syntax used "{}". Templates will '
+            'be removed in a future version'.format(name))
+        if name not in ('[FileListEntry@FloatLayout+TreeViewNode]',
+                        '[FileIconEntry@Widget]',
+                        '[AccordionItemTitle@Label]'):
+            Logger.warning(exception)
+
+        if __debug__:
+            trace('Builder: build template for %s' % name)
+        if name[0] != '[' or name[-1] != ']':
+            raise ParserException(self.ctx, self.line,
+                                  'Invalid template (must be inside [])')
+        item_content = name[1:-1]
+        if '@' not in item_content:
+            raise ParserException(self.ctx, self.line,
+                                  'Invalid template name (missing @)')
+        template_name, template_root_cls = item_content.split('@')
+        self.ctx.templates.append((template_name, template_root_cls, self))
+
+    def __repr__(self):
+        return '<ParserRule name=%r>' % (self.name, )
+
+
+class Parser(object):
+    '''Create a Parser object to parse a Kivy language file or Kivy content.
+    '''
+
+    PROP_ALLOWED = ('canvas.before', 'canvas.after')
+    CLASS_RANGE = list(range(ord('A'), ord('Z') + 1))
+    PROP_RANGE = (
+        list(range(ord('A'), ord('Z') + 1)) +
+        list(range(ord('a'), ord('z') + 1)) +
+        list(range(ord('0'), ord('9') + 1)) + [ord('_')])
+
+    __slots__ = ('rules', 'templates', 'root', 'sourcecode',
+                 'directives', 'filename', 'dynamic_classes')
+
+    def __init__(self, **kwargs):
+        super(Parser, self).__init__()
+        self.rules = []
+        self.templates = []
+        self.root = None
+        self.sourcecode = []
+        self.directives = []
+        self.dynamic_classes = {}
+        self.filename = kwargs.get('filename', None)
+        content = kwargs.get('content', None)
+        if content is None:
+            raise ValueError('No content passed')
+        self.parse(content)
+
+    def execute_directives(self):
+        global __KV_INCLUDES__
+        for ln, cmd in self.directives:
+            cmd = cmd.strip()
+            if __debug__:
+                trace('Parser: got directive <%s>' % cmd)
+            if cmd[:5] == 'kivy ':
+                version = cmd[5:].strip()
+                if len(version.split('.')) == 2:
+                    version += '.0'
+                require(version)
+            elif cmd[:4] == 'set ':
+                try:
+                    name, value = cmd[4:].strip().split(' ', 1)
+                except:
+                    Logger.exception('')
+                    raise ParserException(self, ln, 'Invalid directive syntax')
+                try:
+                    value = eval(value, global_idmap)
+                except:
+                    Logger.exception('')
+                    raise ParserException(self, ln, 'Invalid value')
+                global_idmap[name] = value
+            elif cmd[:8] == 'include ':
+                ref = cmd[8:].strip()
+                force_load = False
+
+                if ref[:6] == 'force ':
+                    ref = ref[6:].strip()
+                    force_load = True
+
+                # if #:include [force] "path with quotes around"
+                if ref[0] == ref[-1] and ref[0] in ('"', "'"):
+                    c = ref[:3].count(ref[0])
+                    ref = ref[c:-c] if c != 2 else ref
+
+                if ref[-3:] != '.kv':
+                    Logger.warning('Lang: {0} does not have a valid Kivy'
+                                'Language extension (.kv)'.format(ref))
+                    break
+                if ref in __KV_INCLUDES__:
+                    if not os.path.isfile(resource_find(ref) or ref):
+                        raise ParserException(self, ln,
+                                              'Invalid or unknown file: {0}'
+                                              .format(ref))
+                    if not force_load:
+                        Logger.warning('Lang: {0} has already been included!'
+                                    .format(ref))
+                        continue
+                    else:
+                        Logger.debug('Lang: Reloading {0} '
+                                     'because include was forced.'
+                                     .format(ref))
+                        kivy.lang.builder.Builder.unload_file(ref)
+                        kivy.lang.builder.Builder.load_file(ref)
+                        continue
+                Logger.debug('Lang: Including file: {0}'.format(0))
+                __KV_INCLUDES__.append(ref)
+                kivy.lang.builder.Builder.load_file(ref)
+            elif cmd[:7] == 'import ':
+                package = cmd[7:].strip()
+                z = package.split()
+                if len(z) != 2:
+                    raise ParserException(self, ln, 'Invalid import syntax')
+                alias, package = z
+                try:
+                    if package not in sys.modules:
+                        try:
+                            mod = importlib.__import__(package)
+                        except ImportError:
+                            module_name = '.'.join(package.split('.')[:-1])
+                            mod = importlib.__import__(module_name)
+                        # resolve the whole thing
+                        for part in package.split('.')[1:]:
+                            mod = getattr(mod, part)
+                    else:
+                        mod = sys.modules[package]
+                    global_idmap[alias] = mod
+                except ImportError:
+                    Logger.exception('')
+                    raise ParserException(self, ln,
+                                          'Unable to import package %r' %
+                                          package)
+            else:
+                raise ParserException(self, ln, 'Unknown directive')
+
+    def parse(self, content):
+        '''Parse the contents of a Parser file and return a list
+        of root objects.
+        '''
+        # Read and parse the lines of the file
+        lines = content.splitlines()
+        if not lines:
+            return
+        num_lines = len(lines)
+        lines = list(zip(list(range(num_lines)), lines))
+        self.sourcecode = lines[:]
+
+        if __debug__:
+            trace('Parser: parsing %d lines' % num_lines)
+
+        # Strip all comments
+        self.strip_comments(lines)
+
+        # Execute directives
+        self.execute_directives()
+
+        # Get object from the first level
+        objects, remaining_lines = self.parse_level(0, lines)
+
+        # Precompile rules tree
+        for rule in objects:
+            rule.precompile()
+
+        # After parsing, there should be no remaining lines
+        # or there's an error we did not catch earlier.
+        if remaining_lines:
+            ln, content = remaining_lines[0]
+            raise ParserException(self, ln, 'Invalid data (not parsed)')
+
+    def strip_comments(self, lines):
+        '''Remove all comments from all lines in-place.
+           Comments need to be on a single line and not at the end of a line.
+           i.e. a comment line's first non-whitespace character must be a #.
+        '''
+        # extract directives
+        for ln, line in lines[:]:
+            stripped = line.strip()
+            if stripped[:2] == '#:':
+                self.directives.append((ln, stripped[2:]))
+            if stripped[:1] == '#':
+                lines.remove((ln, line))
+            if not stripped:
+                lines.remove((ln, line))
+
+    def parse_level(self, level, lines, spaces=0):
+        '''Parse the current level (level * spaces) indentation.
+        '''
+        indent = spaces * level if spaces > 0 else 0
+        objects = []
+
+        current_object = None
+        current_property = None
+        current_propobject = None
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            ln, content = line
+
+            # Get the number of space
+            tmp = content.lstrip(' \t')
+
+            # Replace any tab with 4 spaces
+            tmp = content[:len(content) - len(tmp)]
+            tmp = tmp.replace('\t', '    ')
+
+            # first indent designates the indentation
+            if spaces == 0:
+                spaces = len(tmp)
+
+            count = len(tmp)
+
+            if spaces > 0 and count % spaces != 0:
+                raise ParserException(self, ln,
+                                      'Invalid indentation, '
+                                      'must be a multiple of '
+                                      '%s spaces' % spaces)
+            content = content.strip()
+            rlevel = count // spaces if spaces > 0 else 0
+
+            # Level finished
+            if count < indent:
+                return objects, lines[i - 1:]
+
+            # Current level, create an object
+            elif count == indent:
+                x = content.split(':', 1)
+                if not x[0]:
+                    raise ParserException(self, ln, 'Identifier missing')
+                if (len(x) == 2 and len(x[1]) and
+                        not x[1].lstrip().startswith('#')):
+                    raise ParserException(self, ln,
+                                          'Invalid data after declaration')
+                name = x[0].rstrip()
+                # if it's not a root rule, then we got some restriction
+                # aka, a valid name, without point or everything else
+                if count != 0:
+                    if False in [ord(z) in Parser.PROP_RANGE for z in name]:
+                        raise ParserException(self, ln, 'Invalid class name')
+
+                current_object = ParserRule(self, ln, name, rlevel)
+                current_property = None
+                objects.append(current_object)
+
+            # Next level, is it a property or an object ?
+            elif count == indent + spaces:
+                x = content.split(':', 1)
+                if not x[0]:
+                    raise ParserException(self, ln, 'Identifier missing')
+
+                # It's a class, add to the current object as a children
+                current_property = None
+                name = x[0].rstrip()
+                ignore_prev = name[0] == '-'
+                if ignore_prev:
+                    name = name[1:]
+
+                if ord(name[0]) in Parser.CLASS_RANGE:
+                    if ignore_prev:
+                        raise ParserException(
+                            self, ln, 'clear previous, `-`, not allowed here')
+                    _objects, _lines = self.parse_level(
+                        level + 1, lines[i:], spaces)
+                    if current_object is None:
+                        raise ParserException(self, ln, 'Invalid indentation')
+                    current_object.children = _objects
+                    lines = _lines
+                    i = 0
+
+                # It's a property
+                else:
+                    if name not in Parser.PROP_ALLOWED:
+                        if not all(ord(z) in Parser.PROP_RANGE for z in name):
+                            raise ParserException(self, ln,
+                                                  'Invalid property name')
+                    if len(x) == 1:
+                        raise ParserException(self, ln, 'Syntax error')
+                    value = x[1].strip()
+                    if name == 'id':
+                        if len(value) <= 0:
+                            raise ParserException(self, ln, 'Empty id')
+                        if value in ('self', 'root'):
+                            raise ParserException(
+                                self, ln,
+                                'Invalid id, cannot be "self" or "root"')
+                        current_object.id = value
+                    elif len(value):
+                        rule = ParserRuleProperty(
+                            self, ln, name, value, ignore_prev)
+                        if name[:3] == 'on_':
+                            current_object.handlers.append(rule)
+                        else:
+                            ignore_prev = False
+                            current_object.properties[name] = rule
+                    else:
+                        current_property = name
+                        current_propobject = None
+
+                    if ignore_prev:  # it wasn't consumed
+                        raise ParserException(
+                            self, ln, 'clear previous, `-`, not allowed here')
+
+            # Two more levels?
+            elif count == indent + 2 * spaces:
+                if current_property in (
+                        'canvas', 'canvas.after', 'canvas.before'):
+                    _objects, _lines = self.parse_level(
+                        level + 2, lines[i:], spaces)
+                    rl = ParserRule(self, ln, current_property, rlevel)
+                    rl.children = _objects
+                    if current_property == 'canvas':
+                        current_object.canvas_root = rl
+                    elif current_property == 'canvas.before':
+                        current_object.canvas_before = rl
+                    else:
+                        current_object.canvas_after = rl
+                    current_property = None
+                    lines = _lines
+                    i = 0
+                else:
+                    if current_propobject is None:
+                        current_propobject = ParserRuleProperty(
+                            self, ln, current_property, content)
+                        if not current_property:
+                            raise ParserException(self, ln,
+                                                  "Invalid indentation")
+                        if current_property[:3] == 'on_':
+                            current_object.handlers.append(current_propobject)
+                        else:
+                            current_object.properties[current_property] = \
+                                current_propobject
+                    else:
+                        current_propobject.value += '\n' + content
+
+            # Too much indentation, invalid
+            else:
+                raise ParserException(self, ln,
+                                      'Invalid indentation (too many levels)')
+
+            # Check the next line
+            i += 1
+
+        return objects, []
+
+
+class ParserSelector(object):
+
+    def __init__(self, key):
+        self.key = key.lower()
+
+    def match(self, widget):
+        raise NotImplementedError
+
+    def __repr__(self):
+        return '<%s key=%s>' % (self.__class__.__name__, self.key)
+
+
+class ParserSelectorClass(ParserSelector):
+
+    def match(self, widget):
+        return self.key in widget.cls
+
+
+class ParserSelectorName(ParserSelector):
+
+    parents = {}
+
+    def get_bases(self, cls):
+        for base in cls.__bases__:
+            if base.__name__ == 'object':
+                break
+            yield base
+            if base.__name__ == 'Widget':
+                break
+            for cbase in self.get_bases(base):
+                yield cbase
+
+    def match(self, widget):
+        parents = ParserSelectorName.parents
+        cls = widget.__class__
+        if cls not in parents:
+            classes = [x.__name__.lower() for x in
+                       [cls] + list(self.get_bases(cls))]
+            parents[cls] = classes
+        return self.key in parents[cls]
+
+    def match_rule_name(self, rule_name):
+        return self.key == rule_name.lower()