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