def __init__(self, tpl_element, loop_spec=None):
super().__init__(tpl_element)
if isinstance(tpl_element, For):
# pylint: disable=protected-access; we are cloning self, we can access protected variables
self._var = tpl_element._var
self._cond = tpl_element._cond
self._exp = tpl_element._exp.clone()
self.children = []
self.child_template = tpl_element.child_template.clone()
else:
match = For.SPEC_RE.match(loop_spec)
if match is None:
raise Exception("Invalid loop specification: " + loop_spec)
match = match.groupdict()
self._var = match['loop_var']
sequence_exp = match['sequence_exp']
self._exp, pos = parse(sequence_exp, trailing_garbage_ok=True)
match = For.COND_RE.match(sequence_exp[pos:])
if match:
self._cond, _ = parse(match['condition'])
else:
self._cond = None
self.children = []
self.child_template = _compile(tpl_element)
self._exp.bind('change', self._self_change_chandler)
def __init__(self, tpl_element, model=None, update_interval=None, update_event='input'):
super().__init__(tpl_element)
self._model_change_timer = None
self._input_change_timer = None
self.element = None
self._ctx = None
if isinstance(tpl_element, Model):
# pylint: disable=protected-access; we are cloning Model, we can access protected variables
self._update_event = tpl_element._update_event
self._update_interval = tpl_element._update_interval
self._model = tpl_element.model.clone()
self.child = tpl_element.child.clone()
else:
self._update_event = update_event
if update_interval is not None:
self._update_interval = int(update_interval)
else:
self._update_interval = None
self._model, _ = parse(model)
self.child = _compile(tpl_element)
assert self._model.is_assignable(), "The expression "+model+" does not support assignment"
if self._update_interval:
self._model.bind('change', self._defer_model_change)
else:
self._model.bind('change', self._model_change)
self.child.bind('change', self._subtree_change_handler)
def __init__(self, tpl_element, expression=None):
super().__init__(tpl_element)
self.element = None
self.handler = None
if isinstance(tpl_element, Event):
self.handler = tpl_element.handler.clone()
self.child = tpl_element.child.clone()
self.EVENT = tpl_element.EVENT
else:
self.handler, _ = parse(expression)
if not self.handler.is_function_call():
raise Exception(self.EVENT +
" Handler needs to be a function call: " +
str(expression))
self.child = _compile(tpl_element)
self.child.bind('change', self._subtree_change_handler)
def __init__(self, tpl_element):
super().__init__(tpl_element)
self.children = []
self.child_elements = {}
if isinstance(tpl_element, GenericTagPlugin):
self.element = tpl_element.element.clone()
self.element.clear()
for child in tpl_element.children:
node = child.clone()
node.bind('change', self._subtree_change_handler)
self.children.append(node)
self.child_elements[node] = [self._fence(node)]
else:
self.element = tpl_element.clone()
self.element.clear()
for child in tpl_element.children:
node = _compile(child)
node.bind('change', self._subtree_change_handler)
self.children.append(node)
self.child_elements[node] = [self._fence(node)]
def __init__(self, tpl_element):
super().__init__(tpl_element)
self.element = None
self.values = {}
self.names = []
if isinstance(tpl_element, InterpolatedAttrsPlugin):
for (name, obs) in tpl_element.values.items():
if isinstance(obs, InterpolatedStr):
obs = obs.clone()
obs.bind('change', self._self_change_chandler)
self.values[name] = obs
self.child = tpl_element.child.clone()
else:
for attr in tpl_element.attributes:
if '{{' in attr.value:
obs = InterpolatedStr(attr.value)
obs.bind('change', self._self_change_chandler)
else:
obs = attr.value
self.values[attr.name] = obs
tpl_element.removeAttribute(attr.name)
self.child = _compile(tpl_element)
self.child.bind('change', self._subtree_change_handler)
def __init__(self, tpl_element, **kwargs):
"""
Descendant classes should override this to specify
(via argument names) which attributes from the dom-element
the plugin uses. However, the actual implementation should
just be a single line:
```
super().__init__(tpl_element,...)
```
calling the base constructor which does all the work
(initializing the arguments). Any processing that needs to
be done at compile time should be put into the post_init
method.
"""
super().__init__(tpl_element, **kwargs)
if self._compiled_tpl is None:
self._compiled_tpl = _compile(self.TEMPLATE)
self.tpl = self._compiled_tpl.clone()
if isinstance(tpl_element, UserTag):
self._clone_args(tpl_element)
self.post_clone(tpl_element)
else:
self._process_args(kwargs)
self.post_init()
def __init__(self, tpl_element, name):
super().__init__(tpl_element)
self._template = _compile(tpl_element)
self._name = name