Mercurial > libervia-backend
view sat_frontends/tools/xmlui.py @ 3567:a240748ed686
app manager (docker/weblate): add `WEBLATE_ENABLE_HTTPS`:
The value can be set in `libervia.conf` with `weblate_enable_https`. It defaults to "1".
author | Goffi <goffi@goffi.org> |
---|---|
date | Mon, 14 Jun 2021 12:19:21 +0200 |
parents | be6d91572633 |
children | 524856bd7b19 |
line wrap: on
line source
#!/usr/bin/env python3 # SàT frontend tools # Copyright (C) 2009-2021 Jérôme Poisson (goffi@goffi.org) # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from sat.core.i18n import _ from sat.core.log import getLogger log = getLogger(__name__) from sat_frontends.quick_frontend.constants import Const as C from sat.core import exceptions _class_map = {} CLASS_PANEL = "panel" CLASS_DIALOG = "dialog" CURRENT_LABEL = "current_label" HIDDEN = "hidden" class InvalidXMLUI(Exception): pass class ClassNotRegistedError(Exception): pass # FIXME: this method is duplicated in frontends.tools.xmlui.getText def getText(node): """Get child text nodes @param node: dom Node @return: joined unicode text of all nodes """ data = [] for child in node.childNodes: if child.nodeType == child.TEXT_NODE: data.append(child.wholeText) return "".join(data) class Widget(object): """base Widget""" pass class EmptyWidget(Widget): """Just a placeholder widget""" pass class TextWidget(Widget): """Non interactive text""" pass class LabelWidget(Widget): """Non interactive text""" pass class JidWidget(Widget): """Jabber ID""" pass class DividerWidget(Widget): """Separator""" pass class StringWidget(Widget): """Input widget wich require a string often called Edit in toolkits """ pass class JidInputWidget(Widget): """Input widget wich require a string often called Edit in toolkits """ pass class PasswordWidget(Widget): """Input widget with require a masked string""" pass class TextBoxWidget(Widget): """Input widget with require a long, possibly multilines string often called TextArea in toolkits """ pass class XHTMLBoxWidget(Widget): """Input widget specialised in XHTML editing, a WYSIWYG or specialised editor is expected """ pass class BoolWidget(Widget): """Input widget with require a boolean value often called CheckBox in toolkits """ pass class IntWidget(Widget): """Input widget with require an integer""" pass class ButtonWidget(Widget): """A clickable widget""" pass class ListWidget(Widget): """A widget able to show/choose one or several strings in a list""" pass class JidsListWidget(Widget): """A widget able to show/choose one or several strings in a list""" pass class Container(Widget): """Widget which can contain other ones with a specific layout""" @classmethod def _xmluiAdapt(cls, instance): """Make cls as instance.__class__ cls must inherit from original instance class Usefull when you get a class from UI toolkit """ assert instance.__class__ in cls.__bases__ instance.__class__ = type(cls.__name__, cls.__bases__, dict(cls.__dict__)) class PairsContainer(Container): """Widgets are disposed in rows of two (usually label/input)""" pass class LabelContainer(Container): """Widgets are associated with label or empty widget""" pass class TabsContainer(Container): """A container which several other containers in tabs Often called Notebook in toolkits """ pass class VerticalContainer(Container): """Widgets are disposed vertically""" pass class AdvancedListContainer(Container): """Widgets are disposed in rows with advaned features""" pass class Dialog(object): """base dialog""" def __init__(self, _xmlui_parent): self._xmlui_parent = _xmlui_parent def _xmluiValidated(self, data=None): if data is None: data = {} self._xmluiSetData(C.XMLUI_STATUS_VALIDATED, data) self._xmluiSubmit(data) def _xmluiCancelled(self): data = {C.XMLUI_DATA_CANCELLED: C.BOOL_TRUE} self._xmluiSetData(C.XMLUI_STATUS_CANCELLED, data) self._xmluiSubmit(data) def _xmluiSubmit(self, data): if self._xmlui_parent.submit_id is None: log.debug(_("Nothing to submit")) else: self._xmlui_parent.submit(data) def _xmluiSetData(self, status, data): pass class MessageDialog(Dialog): """Dialog with a OK/Cancel type configuration""" pass class NoteDialog(Dialog): """Short message which doesn't need user confirmation to disappear""" pass class ConfirmDialog(Dialog): """Dialog with a OK/Cancel type configuration""" def _xmluiSetData(self, status, data): if status == C.XMLUI_STATUS_VALIDATED: data[C.XMLUI_DATA_ANSWER] = C.BOOL_TRUE elif status == C.XMLUI_STATUS_CANCELLED: data[C.XMLUI_DATA_ANSWER] = C.BOOL_FALSE class FileDialog(Dialog): """Dialog with a OK/Cancel type configuration""" pass class XMLUIBase(object): """Base class to construct SàT XML User Interface This class must not be instancied directly """ def __init__(self, host, parsed_dom, title=None, flags=None, callback=None, profile=C.PROF_KEY_NONE): """Initialise the XMLUI instance @param host: %(doc_host)s @param parsed_dom: main parsed dom @param title: force the title, or use XMLUI one if None @param flags: list of string which can be: - NO_CANCEL: the UI can't be cancelled - FROM_BACKEND: the UI come from backend (i.e. it's not the direct result of user operation) @param callback(callable, None): if not None, will be used with launchAction: - if None is used, default behaviour will be used (closing the dialog and calling host.actionManager) - if a callback is provided, it will be used instead, so you'll have to manage dialog closing or new xmlui to display, or other action (you can call host.actionManager) The callback will have data, callback_id and profile as arguments """ self.host = host top = parsed_dom.documentElement self.session_id = top.getAttribute("session_id") or None self.submit_id = top.getAttribute("submit") or None self.xmlui_title = title or top.getAttribute("title") or "" self.hidden = {} if flags is None: flags = [] self.flags = flags self.callback = callback or self._defaultCb self.profile = profile @property def user_action(self): return "FROM_BACKEND" not in self.flags def _defaultCb(self, data, cb_id, profile): # TODO: when XMLUI updates will be managed, the _xmluiClose # must be called only if there is no update self._xmluiClose() self.host.actionManager(data, profile=profile) def _isAttrSet(self, name, node): """Return widget boolean attribute status @param name: name of the attribute (e.g. "read_only") @param node: Node instance @return (bool): True if widget's attribute is set (C.BOOL_TRUE) """ read_only = node.getAttribute(name) or C.BOOL_FALSE return read_only.lower().strip() == C.BOOL_TRUE def _getChildNode(self, node, name): """Return the first child node with the given name @param node: Node instance @param name: name of the wanted node @return: The found element or None """ for child in node.childNodes: if child.nodeName == name: return child return None def submit(self, data): self._xmluiClose() if self.submit_id is None: raise ValueError("Can't submit is self.submit_id is not set") if "session_id" in data: raise ValueError( "session_id must no be used in data, it is automaticaly filled with " "self.session_id if present" ) if self.session_id is not None: data["session_id"] = self.session_id self._xmluiLaunchAction(self.submit_id, data) def _xmluiLaunchAction(self, action_id, data): self.host.launchAction( action_id, data, callback=self.callback, profile=self.profile ) def _xmluiClose(self): """Close the window/popup/... where the constructor XMLUI is this method must be overrided """ raise NotImplementedError class ValueGetter(object): """dict like object which return values of widgets""" # FIXME: widget which can keep multiple values are not handled def __init__(self, widgets, attr="value"): self.attr = attr self.widgets = widgets def __getitem__(self, name): return getattr(self.widgets[name], self.attr) def __getattr__(self, name): return self.__getitem__(name) def keys(self): return list(self.widgets.keys()) def items(self): for name, widget in self.widgets.items(): try: value = widget.value except AttributeError: try: value = list(widget.values) except AttributeError: continue yield name, value class XMLUIPanel(XMLUIBase): """XMLUI Panel New frontends can inherit this class to easily implement XMLUI @property widget_factory: factory to create frontend-specific widgets @property dialog_factory: factory to create frontend-specific dialogs """ widget_factory = None def __init__(self, host, parsed_dom, title=None, flags=None, callback=None, ignore=None, whitelist=None, profile=C.PROF_KEY_NONE): """ @param title(unicode, None): title of the @property widgets(dict): widget name => widget map @property widget_value(ValueGetter): retrieve widget value from it's name """ super(XMLUIPanel, self).__init__( host, parsed_dom, title=title, flags=flags, callback=callback, profile=profile ) self.ctrl_list = {} # input widget, used mainly for forms self.widgets = {} # allow to access any named widgets self.widget_value = ValueGetter(self.widgets) self._main_cont = None if ignore is None: ignore = [] self._ignore = ignore if whitelist is not None: if ignore: raise exceptions.InternalError( "ignore and whitelist must not be used at the same time" ) self._whitelist = whitelist else: self._whitelist = None self.constructUI(parsed_dom) @staticmethod def escape(name): """Return escaped name for forms""" return "%s%s" % (C.SAT_FORM_PREFIX, name) @property def main_cont(self): return self._main_cont @property def values(self): """Dict of all widgets values""" return dict(self.widget_value.items()) @main_cont.setter def main_cont(self, value): if self._main_cont is not None: raise ValueError(_("XMLUI can have only one main container")) self._main_cont = value def _parseChilds(self, _xmlui_parent, current_node, wanted=("container",), data=None): """Recursively parse childNodes of an element @param _xmlui_parent: widget container with '_xmluiAppend' method @param current_node: element from which childs will be parsed @param wanted: list of tag names that can be present in the childs to be SàT XMLUI compliant @param data(None, dict): additionnal data which are needed in some cases """ for node in current_node.childNodes: if data is None: data = {} if wanted and not node.nodeName in wanted: raise InvalidXMLUI("Unexpected node: [%s]" % node.nodeName) if node.nodeName == "container": type_ = node.getAttribute("type") if _xmlui_parent is self and type_ not in ("vertical", "tabs"): # main container is not a VerticalContainer and we want one, # so we create one to wrap it _xmlui_parent = self.widget_factory.createVerticalContainer(self) self.main_cont = _xmlui_parent if type_ == "tabs": cont = self.widget_factory.createTabsContainer(_xmlui_parent) self._parseChilds(_xmlui_parent, node, ("tab",), {"tabs_cont": cont}) elif type_ == "vertical": cont = self.widget_factory.createVerticalContainer(_xmlui_parent) self._parseChilds(cont, node, ("widget", "container")) elif type_ == "pairs": cont = self.widget_factory.createPairsContainer(_xmlui_parent) self._parseChilds(cont, node, ("widget", "container")) elif type_ == "label": cont = self.widget_factory.createLabelContainer(_xmlui_parent) self._parseChilds( # FIXME: the "None" value for CURRENT_LABEL doesn't seem # used or even useful, it should probably be removed # and all "is not None" tests for it should be removed too # to be checked for 0.8 cont, node, ("widget", "container"), {CURRENT_LABEL: None} ) elif type_ == "advanced_list": try: columns = int(node.getAttribute("columns")) except (TypeError, ValueError): raise exceptions.DataError("Invalid columns") selectable = node.getAttribute("selectable") or "no" auto_index = node.getAttribute("auto_index") == C.BOOL_TRUE data = {"index": 0} if auto_index else None cont = self.widget_factory.createAdvancedListContainer( _xmlui_parent, columns, selectable ) callback_id = node.getAttribute("callback") or None if callback_id is not None: if selectable == "no": raise ValueError( "can't have selectable=='no' and callback_id at the same time" ) cont._xmlui_callback_id = callback_id cont._xmluiOnSelect(self.onAdvListSelect) self._parseChilds(cont, node, ("row",), data) else: log.warning(_("Unknown container [%s], using default one") % type_) cont = self.widget_factory.createVerticalContainer(_xmlui_parent) self._parseChilds(cont, node, ("widget", "container")) try: xmluiAppend = _xmlui_parent._xmluiAppend except ( AttributeError, TypeError, ): # XXX: TypeError is here because pyjamas raise a TypeError instead of an AttributeError if _xmlui_parent is self: self.main_cont = cont else: raise Exception( _("Internal Error, container has not _xmluiAppend method") ) else: xmluiAppend(cont) elif node.nodeName == "tab": name = node.getAttribute("name") label = node.getAttribute("label") selected = C.bool(node.getAttribute("selected") or C.BOOL_FALSE) if not name or not "tabs_cont" in data: raise InvalidXMLUI if self.type == "param": self._current_category = ( name ) # XXX: awful hack because params need category and we don't keep parent tab_cont = data["tabs_cont"] new_tab = tab_cont._xmluiAddTab(label or name, selected) self._parseChilds(new_tab, node, ("widget", "container")) elif node.nodeName == "row": try: index = str(data["index"]) except KeyError: index = node.getAttribute("index") or None else: data["index"] += 1 _xmlui_parent._xmluiAddRow(index) self._parseChilds(_xmlui_parent, node, ("widget", "container")) elif node.nodeName == "widget": name = node.getAttribute("name") if name and ( name in self._ignore or self._whitelist is not None and name not in self._whitelist ): # current widget is ignored, but there may be already a label if CURRENT_LABEL in data: curr_label = data.pop(CURRENT_LABEL) if curr_label is not None: # if so, we remove it from parent _xmlui_parent._xmluiRemove(curr_label) continue type_ = node.getAttribute("type") value_elt = self._getChildNode(node, "value") if value_elt is not None: value = getText(value_elt) else: value = ( node.getAttribute("value") if node.hasAttribute("value") else "" ) if type_ == "empty": ctrl = self.widget_factory.createEmptyWidget(_xmlui_parent) if CURRENT_LABEL in data: data[CURRENT_LABEL] = None elif type_ == "text": ctrl = self.widget_factory.createTextWidget(_xmlui_parent, value) elif type_ == "label": ctrl = self.widget_factory.createLabelWidget(_xmlui_parent, value) data[CURRENT_LABEL] = ctrl elif type_ == "hidden": if name in self.hidden: raise exceptions.ConflictError("Conflict on hidden value with " "name {name}".format(name=name)) self.hidden[name] = value continue elif type_ == "jid": ctrl = self.widget_factory.createJidWidget(_xmlui_parent, value) elif type_ == "divider": style = node.getAttribute("style") or "line" ctrl = self.widget_factory.createDividerWidget(_xmlui_parent, style) elif type_ == "string": ctrl = self.widget_factory.createStringWidget( _xmlui_parent, value, self._isAttrSet("read_only", node) ) self.ctrl_list[name] = {"type": type_, "control": ctrl} elif type_ == "jid_input": ctrl = self.widget_factory.createJidInputWidget( _xmlui_parent, value, self._isAttrSet("read_only", node) ) self.ctrl_list[name] = {"type": type_, "control": ctrl} elif type_ == "password": ctrl = self.widget_factory.createPasswordWidget( _xmlui_parent, value, self._isAttrSet("read_only", node) ) self.ctrl_list[name] = {"type": type_, "control": ctrl} elif type_ == "textbox": ctrl = self.widget_factory.createTextBoxWidget( _xmlui_parent, value, self._isAttrSet("read_only", node) ) self.ctrl_list[name] = {"type": type_, "control": ctrl} elif type_ == "xhtmlbox": ctrl = self.widget_factory.createXHTMLBoxWidget( _xmlui_parent, value, self._isAttrSet("read_only", node) ) self.ctrl_list[name] = {"type": type_, "control": ctrl} elif type_ == "bool": ctrl = self.widget_factory.createBoolWidget( _xmlui_parent, value == C.BOOL_TRUE, self._isAttrSet("read_only", node), ) self.ctrl_list[name] = {"type": type_, "control": ctrl} elif type_ == "int": ctrl = self.widget_factory.createIntWidget( _xmlui_parent, value, self._isAttrSet("read_only", node) ) self.ctrl_list[name] = {"type": type_, "control": ctrl} elif type_ == "list": style = [] if node.getAttribute("multi") == "yes" else ["single"] for attr in ("noselect", "extensible", "reducible", "inline"): if node.getAttribute(attr) == "yes": style.append(attr) _options = [ (option.getAttribute("value"), option.getAttribute("label")) for option in node.getElementsByTagName("option") ] _selected = [ option.getAttribute("value") for option in node.getElementsByTagName("option") if option.getAttribute("selected") == C.BOOL_TRUE ] ctrl = self.widget_factory.createListWidget( _xmlui_parent, _options, _selected, style ) self.ctrl_list[name] = {"type": type_, "control": ctrl} elif type_ == "jids_list": style = [] jids = [getText(jid_) for jid_ in node.getElementsByTagName("jid")] ctrl = self.widget_factory.createJidsListWidget( _xmlui_parent, jids, style ) self.ctrl_list[name] = {"type": type_, "control": ctrl} elif type_ == "button": callback_id = node.getAttribute("callback") ctrl = self.widget_factory.createButtonWidget( _xmlui_parent, value, self.onButtonPress ) ctrl._xmlui_param_id = ( callback_id, [ field.getAttribute("name") for field in node.getElementsByTagName("field_back") ], ) else: log.error( _("FIXME FIXME FIXME: widget type [%s] is not implemented") % type_ ) raise NotImplementedError( _("FIXME FIXME FIXME: type [%s] is not implemented") % type_ ) if name: self.widgets[name] = ctrl if self.type == "param" and type_ not in ("text", "button"): try: ctrl._xmluiOnChange(self.onParamChange) ctrl._param_category = self._current_category except ( AttributeError, TypeError, ): # XXX: TypeError is here because pyjamas raise a TypeError instead # of an AttributeError if not isinstance( ctrl, (EmptyWidget, TextWidget, LabelWidget, JidWidget) ): log.warning(_("No change listener on [%s]") % ctrl) elif type_ != "text": callback = node.getAttribute("internal_callback") or None if callback: fields = [ field.getAttribute("name") for field in node.getElementsByTagName("internal_field") ] cb_data = self.getInternalCallbackData(callback, node) ctrl._xmlui_param_internal = (callback, fields, cb_data) if type_ == "button": ctrl._xmluiOnClick(self.onChangeInternal) else: ctrl._xmluiOnChange(self.onChangeInternal) ctrl._xmlui_name = name _xmlui_parent._xmluiAppend(ctrl) if CURRENT_LABEL in data and not isinstance(ctrl, LabelWidget): curr_label = data.pop(CURRENT_LABEL) if curr_label is not None: # this key is set in LabelContainer, when present # we can associate the label with the widget it is labelling curr_label._xmlui_for_name = name else: raise NotImplementedError(_("Unknown tag [%s]") % node.nodeName) def constructUI(self, parsed_dom, post_treat=None): """Actually construct the UI @param parsed_dom: main parsed dom @param post_treat: frontend specific treatments to do once the UI is constructed @return: constructed widget """ top = parsed_dom.documentElement self.type = top.getAttribute("type") if top.nodeName != "sat_xmlui" or not self.type in [ "form", "param", "window", "popup", ]: raise InvalidXMLUI if self.type == "param": self.param_changed = set() self._parseChilds(self, parsed_dom.documentElement) if post_treat is not None: post_treat() def _xmluiSetParam(self, name, value, category): self.host.bridge.setParam(name, value, category, profile_key=self.profile) ##EVENTS## def onParamChange(self, ctrl): """Called when type is param and a widget to save is modified @param ctrl: widget modified """ assert self.type == "param" self.param_changed.add(ctrl) def onAdvListSelect(self, ctrl): data = {} widgets = ctrl._xmluiGetSelectedWidgets() for wid in widgets: try: name = self.escape(wid._xmlui_name) value = wid._xmluiGetValue() data[name] = value except ( AttributeError, TypeError, ): # XXX: TypeError is here because pyjamas raise a TypeError instead of an AttributeError pass idx = ctrl._xmluiGetSelectedIndex() if idx is not None: data["index"] = idx callback_id = ctrl._xmlui_callback_id if callback_id is None: log.info(_("No callback_id found")) return self._xmluiLaunchAction(callback_id, data) def onButtonPress(self, button): """Called when an XMLUI button is clicked Launch the action associated to the button @param button: the button clicked """ callback_id, fields = button._xmlui_param_id if not callback_id: # the button is probably bound to an internal action return data = {} for field in fields: escaped = self.escape(field) ctrl = self.ctrl_list[field] if isinstance(ctrl["control"], ListWidget): data[escaped] = "\t".join(ctrl["control"]._xmluiGetSelectedValues()) else: data[escaped] = ctrl["control"]._xmluiGetValue() self._xmluiLaunchAction(callback_id, data) def onChangeInternal(self, ctrl): """Called when a widget that has been bound to an internal callback is changed. This is used to perform some UI actions without communicating with the backend. See sat.tools.xml_tools.Widget.setInternalCallback for more details. @param ctrl: widget modified """ action, fields, data = ctrl._xmlui_param_internal if action not in ("copy", "move", "groups_of_contact"): raise NotImplementedError( _("FIXME: XMLUI internal action [%s] is not implemented") % action ) def copy_move(source, target): """Depending of 'action' value, copy or move from source to target.""" if isinstance(target, ListWidget): if isinstance(source, ListWidget): values = source._xmluiGetSelectedValues() else: values = [source._xmluiGetValue()] if action == "move": source._xmluiSetValue("") values = [value for value in values if value] if values: target._xmluiAddValues(values, select=True) else: if isinstance(source, ListWidget): value = ", ".join(source._xmluiGetSelectedValues()) else: value = source._xmluiGetValue() if action == "move": source._xmluiSetValue("") target._xmluiSetValue(value) def groups_of_contact(source, target): """Select in target the groups of the contact which is selected in source.""" assert isinstance(source, ListWidget) assert isinstance(target, ListWidget) try: contact_jid_s = source._xmluiGetSelectedValues()[0] except IndexError: return target._xmluiSelectValues(data[contact_jid_s]) pass source = None for field in fields: widget = self.ctrl_list[field]["control"] if not source: source = widget continue if action in ("copy", "move"): copy_move(source, widget) elif action == "groups_of_contact": groups_of_contact(source, widget) source = None def getInternalCallbackData(self, action, node): """Retrieve from node the data needed to perform given action. @param action (string): a value from the one that can be passed to the 'callback' parameter of sat.tools.xml_tools.Widget.setInternalCallback @param node (DOM Element): the node of the widget that triggers the callback """ # TODO: it would be better to not have a specific way to retrieve # data for each action, but instead to have a generic method to # extract any kind of data structure from the 'internal_data' element. try: # data is stored in the first 'internal_data' element of the node data_elts = node.getElementsByTagName("internal_data")[0].childNodes except IndexError: return None data = {} if ( action == "groups_of_contact" ): # return a dict(key: string, value: list[string]) for elt in data_elts: jid_s = elt.getAttribute("name") data[jid_s] = [] for value_elt in elt.childNodes: data[jid_s].append(value_elt.getAttribute("name")) return data def onFormSubmitted(self, ignore=None): """An XMLUI form has been submited call the submit action associated with this form """ selected_values = [] for ctrl_name in self.ctrl_list: escaped = self.escape(ctrl_name) ctrl = self.ctrl_list[ctrl_name] if isinstance(ctrl["control"], ListWidget): selected_values.append( (escaped, "\t".join(ctrl["control"]._xmluiGetSelectedValues())) ) else: selected_values.append((escaped, ctrl["control"]._xmluiGetValue())) data = dict(selected_values) for key, value in self.hidden.items(): data[self.escape(key)] = value if self.submit_id is not None: self.submit(data) else: log.warning( _("The form data is not sent back, the type is not managed properly") ) self._xmluiClose() def onFormCancelled(self, *__): """Called when a form is cancelled""" log.debug(_("Cancelling form")) if self.submit_id is not None: data = {C.XMLUI_DATA_CANCELLED: C.BOOL_TRUE} self.submit(data) else: log.warning( _("The form data is not sent back, the type is not managed properly") ) self._xmluiClose() def onSaveParams(self, ignore=None): """Params are saved, we send them to backend self.type must be param """ assert self.type == "param" for ctrl in self.param_changed: if isinstance(ctrl, ListWidget): value = "\t".join(ctrl._xmluiGetSelectedValues()) else: value = ctrl._xmluiGetValue() param_name = ctrl._xmlui_name.split(C.SAT_PARAM_SEPARATOR)[1] self._xmluiSetParam(param_name, value, ctrl._param_category) self._xmluiClose() def show(self, *args, **kwargs): pass class AIOXMLUIPanel(XMLUIPanel): """Asyncio compatible version of XMLUIPanel""" async def onFormSubmitted(self, ignore=None): """An XMLUI form has been submited call the submit action associated with this form """ selected_values = [] for ctrl_name in self.ctrl_list: escaped = self.escape(ctrl_name) ctrl = self.ctrl_list[ctrl_name] if isinstance(ctrl["control"], ListWidget): selected_values.append( (escaped, "\t".join(ctrl["control"]._xmluiGetSelectedValues())) ) else: selected_values.append((escaped, ctrl["control"]._xmluiGetValue())) data = dict(selected_values) for key, value in self.hidden.items(): data[self.escape(key)] = value if self.submit_id is not None: await self.submit(data) else: log.warning( _("The form data is not sent back, the type is not managed properly") ) self._xmluiClose() async def onFormCancelled(self, *__): """Called when a form is cancelled""" log.debug(_("Cancelling form")) if self.submit_id is not None: data = {C.XMLUI_DATA_CANCELLED: C.BOOL_TRUE} await self.submit(data) else: log.warning( _("The form data is not sent back, the type is not managed properly") ) self._xmluiClose() async def submit(self, data): self._xmluiClose() if self.submit_id is None: raise ValueError("Can't submit is self.submit_id is not set") if "session_id" in data: raise ValueError( "session_id must no be used in data, it is automaticaly filled with " "self.session_id if present" ) if self.session_id is not None: data["session_id"] = self.session_id await self._xmluiLaunchAction(self.submit_id, data) async def _xmluiLaunchAction(self, action_id, data): await self.host.launchAction( action_id, data, callback=self.callback, profile=self.profile ) class XMLUIDialog(XMLUIBase): dialog_factory = None def __init__( self, host, parsed_dom, title=None, flags=None, callback=None, ignore=None, whitelist=None, profile=C.PROF_KEY_NONE, ): super(XMLUIDialog, self).__init__( host, parsed_dom, title=title, flags=flags, callback=callback, profile=profile ) top = parsed_dom.documentElement dlg_elt = self._getChildNode(top, "dialog") if dlg_elt is None: raise ValueError("Invalid XMLUI: no Dialog element found !") dlg_type = dlg_elt.getAttribute("type") or C.XMLUI_DIALOG_MESSAGE try: mess_elt = self._getChildNode(dlg_elt, C.XMLUI_DATA_MESS) message = getText(mess_elt) except ( TypeError, AttributeError, ): # XXX: TypeError is here because pyjamas raise a TypeError instead of an AttributeError message = "" level = dlg_elt.getAttribute(C.XMLUI_DATA_LVL) or C.XMLUI_DATA_LVL_INFO if dlg_type == C.XMLUI_DIALOG_MESSAGE: self.dlg = self.dialog_factory.createMessageDialog( self, self.xmlui_title, message, level ) elif dlg_type == C.XMLUI_DIALOG_NOTE: self.dlg = self.dialog_factory.createNoteDialog( self, self.xmlui_title, message, level ) elif dlg_type == C.XMLUI_DIALOG_CONFIRM: try: buttons_elt = self._getChildNode(dlg_elt, "buttons") buttons_set = ( buttons_elt.getAttribute("set") or C.XMLUI_DATA_BTNS_SET_DEFAULT ) except ( TypeError, AttributeError, ): # XXX: TypeError is here because pyjamas raise a TypeError instead of an AttributeError buttons_set = C.XMLUI_DATA_BTNS_SET_DEFAULT self.dlg = self.dialog_factory.createConfirmDialog( self, self.xmlui_title, message, level, buttons_set ) elif dlg_type == C.XMLUI_DIALOG_FILE: try: file_elt = self._getChildNode(dlg_elt, "file") filetype = file_elt.getAttribute("type") or C.XMLUI_DATA_FILETYPE_DEFAULT except ( TypeError, AttributeError, ): # XXX: TypeError is here because pyjamas raise a TypeError instead of an AttributeError filetype = C.XMLUI_DATA_FILETYPE_DEFAULT self.dlg = self.dialog_factory.createFileDialog( self, self.xmlui_title, message, level, filetype ) else: raise ValueError("Unknown dialog type [%s]" % dlg_type) def show(self): self.dlg._xmluiShow() def _xmluiClose(self): self.dlg._xmluiClose() def registerClass(type_, class_): """Register the class to use with the factory @param type_: one of: CLASS_PANEL: classical XMLUI interface CLASS_DIALOG: XMLUI dialog @param class_: the class to use to instanciate given type """ # TODO: remove this method, as there are seme use cases where different XMLUI # classes can be used in the same frontend, so a global value is not good assert type_ in (CLASS_PANEL, CLASS_DIALOG) log.warning("registerClass for XMLUI is deprecated, please use partial with " "xmlui.create and class_map instead") if type_ in _class_map: log.debug(_("XMLUI class already registered for {type_}, ignoring").format( type_=type_)) return _class_map[type_] = class_ def create(host, xml_data, title=None, flags=None, dom_parse=None, dom_free=None, callback=None, ignore=None, whitelist=None, class_map=None, profile=C.PROF_KEY_NONE): """ @param dom_parse: methode equivalent to minidom.parseString (but which must manage unicode), or None to use default one @param dom_free: method used to free the parsed DOM @param ignore(list[unicode], None): name of widgets to ignore widgets with name in this list and their label will be ignored @param whitelist(list[unicode], None): name of widgets to keep when not None, only widgets in this list and their label will be kept mutually exclusive with ignore """ if class_map is None: class_map = _class_map if dom_parse is None: from xml.dom import minidom dom_parse = lambda xml_data: minidom.parseString(xml_data.encode("utf-8")) dom_free = lambda parsed_dom: parsed_dom.unlink() else: dom_parse = dom_parse dom_free = dom_free or (lambda parsed_dom: None) parsed_dom = dom_parse(xml_data) top = parsed_dom.documentElement ui_type = top.getAttribute("type") try: if ui_type != C.XMLUI_DIALOG: cls = class_map[CLASS_PANEL] else: cls = class_map[CLASS_DIALOG] except KeyError: raise ClassNotRegistedError( _("You must register classes with registerClass before creating a XMLUI") ) xmlui = cls( host, parsed_dom, title=title, flags=flags, callback=callback, ignore=ignore, whitelist=whitelist, profile=profile, ) dom_free(parsed_dom) return xmlui