core, frontends: XMLUI refactoring:
- XMLUI now use objects with 2 main classes: widgets (button, label, etc), and container which contain widgets according to a layout
- widgets and containers classes are found through introspection, thereby it's really easy to add a new one
- there is still the AddWidgetName helper, for example AddText('jid', 'test@example.net') will add a StringWidget with name "jid" and default value "test@example.net"
- container can be inside other containers. changeContainer change the first parent container
This commit is contained in:
Goffi
parent
72fd99f679
commit
b3fb68cb63
8 changed files with 590 additions and 438 deletions
|
|
@ -103,12 +103,6 @@ class PrimitivusListWidget(xmlui.ListWidget, sat_widgets.List, PrimitivusEvents)
|
|||
return [option.value for option in self.getSelectedValues()]
|
||||
|
||||
|
||||
class PrimitivusAdvancedListWidget(PrimitivusListWidget, PrimitivusEvents):
|
||||
|
||||
def __init__(self, parent, options, flags):
|
||||
sat_widgets.List.__init__(self, options=options, style=flags, max_height=20)
|
||||
|
||||
|
||||
class PrimitivusPairsContainer(xmlui.PairsContainer, urwid.WidgetWrap):
|
||||
|
||||
def __init__(self, parent, weight_0='1', weight_1='1'):
|
||||
|
|
@ -148,7 +142,6 @@ class PrimitivusTabsContainer(xmlui.TabsContainer, sat_widgets.TabsContainer):
|
|||
|
||||
class PrimitivusVerticalContainer(xmlui.VerticalContainer, urwid.ListBox):
|
||||
|
||||
|
||||
def __init__(self, parent):
|
||||
urwid.ListBox.__init__(self, urwid.SimpleListWalker([]))
|
||||
|
||||
|
|
@ -169,13 +162,14 @@ class XMLUI(xmlui.XMLUI, urwid.WidgetWrap):
|
|||
def __init__(self, host, xml_data, title = None, flags = None):
|
||||
self._dest = "window"
|
||||
xmlui.XMLUI.__init__(self, host, xml_data, title, flags)
|
||||
urwid.WidgetWrap.__init__(self, self.main_cont)
|
||||
|
||||
def constructUI(self, xml_data):
|
||||
def postTreat(ret_wid):
|
||||
assert ret_wid.body
|
||||
def postTreat():
|
||||
assert self.main_cont.body
|
||||
|
||||
if isinstance(ret_wid.body[0],sat_widgets.TabsContainer):
|
||||
ret_wid = ret_wid.body[0] #xxx: awfull hack cause TabsContainer is a BoxWidget, can't be inside a ListBox
|
||||
if isinstance(self.main_cont.body[0],sat_widgets.TabsContainer):
|
||||
self._main_cont = self.main_cont.body[0] #xxx: awfull hack cause TabsContainer is a BoxWidget, can't be inside a ListBox
|
||||
|
||||
if self.type == 'form':
|
||||
buttons = []
|
||||
|
|
@ -184,19 +178,18 @@ class XMLUI(xmlui.XMLUI, urwid.WidgetWrap):
|
|||
buttons.append(urwid.Button(_('Cancel'),self.onFormCancelled))
|
||||
max_len = max([len(button.get_label()) for button in buttons])
|
||||
grid_wid = urwid.GridFlow(buttons,max_len+4,1,0,'center')
|
||||
ret_wid.body.append(grid_wid)
|
||||
self.main_cont.body.append(grid_wid)
|
||||
elif self.type == 'param':
|
||||
assert(isinstance(ret_wid,sat_widgets.TabsContainer))
|
||||
assert(isinstance(self.main_cont,sat_widgets.TabsContainer))
|
||||
buttons = []
|
||||
buttons.append(sat_widgets.CustomButton(_('Save'),self.onSaveParams))
|
||||
buttons.append(sat_widgets.CustomButton(_('Cancel'),lambda x:self.host.removeWindow()))
|
||||
max_len = max([button.getSize() for button in buttons])
|
||||
grid_wid = urwid.GridFlow(buttons,max_len,1,0,'center')
|
||||
ret_wid.addFooter(grid_wid)
|
||||
return ret_wid
|
||||
self.main_cont.addFooter(grid_wid)
|
||||
|
||||
widget = super(XMLUI, self).constructUI(xml_data, postTreat)
|
||||
urwid.WidgetWrap.__init__(self, widget)
|
||||
super(XMLUI, self).constructUI(xml_data, postTreat)
|
||||
urwid.WidgetWrap.__init__(self, self.main_cont)
|
||||
|
||||
def show(self, show_type='popup', valign='middle'):
|
||||
"""Show the constructed UI
|
||||
|
|
|
|||
|
|
@ -89,9 +89,6 @@ class ListWidget(Widget):
|
|||
""" A widget able to show/choose one or several strings in a list """
|
||||
|
||||
|
||||
class AdvancedListWidget(Widget):
|
||||
pass #TODO
|
||||
|
||||
class Container(Widget):
|
||||
""" Widget which can contain other ones with a specific layout """
|
||||
|
||||
|
|
@ -157,103 +154,60 @@ class XMLUI(object):
|
|||
flags = []
|
||||
self.flags = flags
|
||||
self.ctrl_list = {} # usefull to access ctrl
|
||||
self._main_cont = None
|
||||
self.constructUI(xml_data)
|
||||
|
||||
def _parseElems(self, node, parent, post_treat=None):
|
||||
""" Parse elements inside a <layout> tags, and add them to the parent
|
||||
@param node: current XMLUI node
|
||||
@param parent: parent container
|
||||
@param post_treat: frontend specific treatments do to on each element
|
||||
@property
|
||||
def main_cont(self):
|
||||
return self._main_cont
|
||||
|
||||
"""
|
||||
for elem in node.childNodes:
|
||||
if elem.nodeName != "elem":
|
||||
raise NotImplementedError(_('Unknown tag [%s]') % elem.nodeName)
|
||||
id_ = elem.getAttribute("id")
|
||||
name = elem.getAttribute("name")
|
||||
type_ = elem.getAttribute("type")
|
||||
value = elem.getAttribute("value") if elem.hasAttribute('value') else u''
|
||||
if type_=="empty":
|
||||
ctrl = self.widget_factory.createEmptyWidget(parent)
|
||||
elif type_=="text":
|
||||
try:
|
||||
value = elem.childNodes[0].wholeText
|
||||
except IndexError:
|
||||
warning (_("text node has no child !"))
|
||||
ctrl = self.widget_factory.createTextWidget(parent, value)
|
||||
elif type_=="label":
|
||||
ctrl = self.widget_factory.createTextWidget(parent, value+": ")
|
||||
elif type_=="string":
|
||||
ctrl = self.widget_factory.createStringWidget(parent, value)
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="password":
|
||||
ctrl = self.widget_factory.createPasswordWidget(parent, value)
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="textbox":
|
||||
ctrl = self.widget_factory.createTextBoxWidget(parent, value)
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="bool":
|
||||
ctrl = self.widget_factory.createBoolWidget(parent, value=='true')
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="list":
|
||||
style=[] if elem.getAttribute("multi")=='yes' else ['single']
|
||||
_options = [(option.getAttribute("value"), option.getAttribute("label")) for option in elem.getElementsByTagName("option")]
|
||||
ctrl = self.widget_factory.createListWidget(parent, _options, style)
|
||||
ctrl._xmluiSelectValue(elem.getAttribute("value"))
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="button":
|
||||
callback_id = elem.getAttribute("callback")
|
||||
ctrl = self.widget_factory.createButtonWidget(parent, value, self.onButtonPress)
|
||||
ctrl._xmlui_param_id = (callback_id,[field.getAttribute('name') for field in elem.getElementsByTagName("field_back")])
|
||||
elif type_=="advanced_list":
|
||||
_options = [getText(txt_elt) for txt_elt in elem.getElementsByTagName("text")]
|
||||
ctrl = self.widget_factory.createListWidget(parent, _options, ['can_select_none'])
|
||||
ctrl._xmluiSelectValue(elem.getAttribute("value"))
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
else:
|
||||
error(_("FIXME FIXME FIXME: type [%s] is not implemented") % type_)
|
||||
raise NotImplementedError(_("FIXME FIXME FIXME: type [%s] is not implemented") % type_)
|
||||
@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
|
||||
|
||||
if self.type == 'param':
|
||||
try:
|
||||
ctrl._xmluiOnChange(self.onParamChange)
|
||||
ctrl._param_category = self._current_category
|
||||
ctrl._param_name = name.split(Const.SAT_PARAM_SEPARATOR)[1]
|
||||
except AttributeError:
|
||||
if not isinstance(ctrl, (EmptyWidget, TextWidget)):
|
||||
warning(_("No change listener on [%s]" % ctrl))
|
||||
|
||||
if post_treat is not None:
|
||||
post_treat(ctrl, id_, name, type_, value)
|
||||
parent._xmluiAppend(ctrl)
|
||||
|
||||
def _parseChilds(self, current, elem, wanted = ['layout'], data = None):
|
||||
def _parseChilds(self, parent, current_node, wanted = ('container',), data = None):
|
||||
""" Recursively parse childNodes of an elemen
|
||||
@param current: widget container with '_xmluiAppend' method
|
||||
@param elem: element from which childs will be parsed
|
||||
@param 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: additionnal data which are needed in some cases
|
||||
|
||||
"""
|
||||
for node in elem.childNodes:
|
||||
for node in current_node.childNodes:
|
||||
if wanted and not node.nodeName in wanted:
|
||||
raise InvalidXMLUI
|
||||
if node.nodeName == "layout":
|
||||
|
||||
if node.nodeName == "container":
|
||||
type_ = node.getAttribute('type')
|
||||
if parent is self and type_ != 'vertical':
|
||||
# main container is not a VerticalContainer and we want one, so we create one to wrap it
|
||||
parent = self.widget_factory.createVerticalContainer(self)
|
||||
self.main_cont = parent
|
||||
if type_ == "tabs":
|
||||
tab_cont = self.widget_factory.createTabsContainer(current)
|
||||
self._parseChilds(current, node, ['category'], tab_cont)
|
||||
current._xmluiAppend(tab_cont)
|
||||
cont = self.widget_factory.createTabsContainer(parent)
|
||||
self._parseChilds(parent, node, ('tab',), cont)
|
||||
elif type_ == "vertical":
|
||||
self._parseElems(node, current)
|
||||
cont = self.widget_factory.createVerticalContainer(parent)
|
||||
self._parseChilds(cont, node, ('widget', 'container'))
|
||||
elif type_ == "pairs":
|
||||
pairs = self.widget_factory.createPairsContainer(current)
|
||||
self._parseElems(node, pairs)
|
||||
current._xmluiAppend(pairs)
|
||||
cont = self.widget_factory.createPairsContainer(parent)
|
||||
self._parseChilds(cont, node, ('widget', 'container'))
|
||||
else:
|
||||
warning(_("Unknown layout [%s], using default one") % type_)
|
||||
self._parseElems(node, current)
|
||||
elif node.nodeName == "category":
|
||||
warning(_("Unknown container [%s], using default one") % type_)
|
||||
cont = self.widget_factory.createVerticalContainer(parent)
|
||||
self._parseChilds(cont, node, ('widget', 'container'))
|
||||
try:
|
||||
parent._xmluiAppend(cont)
|
||||
except AttributeError:
|
||||
if parent is self:
|
||||
self.main_cont = cont
|
||||
else:
|
||||
raise Exception(_("Internal Error, container has not _xmluiAppend method"))
|
||||
|
||||
elif node.nodeName == "tab":
|
||||
name = node.getAttribute('name')
|
||||
label = node.getAttribute('label')
|
||||
if not name or not isinstance(data, TabsContainer):
|
||||
|
|
@ -262,9 +216,62 @@ class XMLUI(object):
|
|||
self._current_category = name #XXX: awful hack because params need category and we don't keep parent
|
||||
tab_cont = data
|
||||
new_tab = tab_cont._xmluiAddTab(label or name)
|
||||
self._parseChilds(new_tab, node, ['layout'])
|
||||
self._parseChilds(new_tab, node, ('widget', 'container'))
|
||||
|
||||
elif node.nodeName == "widget":
|
||||
id_ = node.getAttribute("id")
|
||||
name = node.getAttribute("name")
|
||||
type_ = node.getAttribute("type")
|
||||
value = node.getAttribute("value") if node.hasAttribute('value') else u''
|
||||
if type_=="empty":
|
||||
ctrl = self.widget_factory.createEmptyWidget(parent)
|
||||
elif type_=="text":
|
||||
try:
|
||||
value = node.childNodes[0].wholeText
|
||||
except IndexError:
|
||||
warning (_("text node has no child !"))
|
||||
ctrl = self.widget_factory.createTextWidget(parent, value)
|
||||
elif type_=="label":
|
||||
ctrl = self.widget_factory.createTextWidget(parent, value+": ")
|
||||
elif type_=="string":
|
||||
ctrl = self.widget_factory.createStringWidget(parent, value)
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="password":
|
||||
ctrl = self.widget_factory.createPasswordWidget(parent, value)
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="textbox":
|
||||
ctrl = self.widget_factory.createTextBoxWidget(parent, value)
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="bool":
|
||||
ctrl = self.widget_factory.createBoolWidget(parent, value=='true')
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="list":
|
||||
style=[] if node.getAttribute("multi")=='yes' else ['single']
|
||||
_options = [(option.getAttribute("value"), option.getAttribute("label")) for option in node.getElementsByTagName("option")]
|
||||
ctrl = self.widget_factory.createListWidget(parent, _options, style)
|
||||
ctrl._xmluiSelectValue(node.getAttribute("value"))
|
||||
self.ctrl_list[name] = ({'type':type_, 'control':ctrl})
|
||||
elif type_=="button":
|
||||
callback_id = node.getAttribute("callback")
|
||||
ctrl = self.widget_factory.createButtonWidget(parent, value, self.onButtonPress)
|
||||
ctrl._xmlui_param_id = (callback_id,[field.getAttribute('name') for field in node.getElementsByTagName("field_back")])
|
||||
else:
|
||||
error(_("FIXME FIXME FIXME: widget type [%s] is not implemented") % type_)
|
||||
raise NotImplementedError(_("FIXME FIXME FIXME: type [%s] is not implemented") % type_)
|
||||
|
||||
if self.type == 'param':
|
||||
try:
|
||||
ctrl._xmluiOnChange(self.onParamChange)
|
||||
ctrl._param_category = self._current_category
|
||||
ctrl._param_name = name.split(Const.SAT_PARAM_SEPARATOR)[1]
|
||||
except AttributeError:
|
||||
if not isinstance(ctrl, (EmptyWidget, TextWidget)):
|
||||
warning(_("No change listener on [%s]" % ctrl))
|
||||
|
||||
parent._xmluiAppend(ctrl)
|
||||
|
||||
else:
|
||||
raise NotImplementedError(_('Unknown tag'))
|
||||
raise NotImplementedError(_('Unknown tag [%s]') % node.nodeName)
|
||||
|
||||
def constructUI(self, xml_data, post_treat=None):
|
||||
""" Actually construct the UI
|
||||
|
|
@ -272,8 +279,6 @@ class XMLUI(object):
|
|||
@param post_treat: frontend specific treatments to do once the UI is constructed
|
||||
@return: constructed widget
|
||||
"""
|
||||
ret_wid = self.widget_factory.createVerticalContainer(self)
|
||||
|
||||
cat_dom = self.dom_parse(xml_data)
|
||||
top=cat_dom.documentElement
|
||||
self.type = top.getAttribute("type")
|
||||
|
|
@ -286,16 +291,13 @@ class XMLUI(object):
|
|||
if self.type == 'param':
|
||||
self.param_changed = set()
|
||||
|
||||
self._parseChilds(ret_wid, cat_dom.documentElement)
|
||||
self._parseChilds(self, cat_dom.documentElement)
|
||||
|
||||
if post_treat is not None:
|
||||
ret_wid = post_treat(ret_wid)
|
||||
post_treat()
|
||||
|
||||
self.dom_free(cat_dom)
|
||||
|
||||
return ret_wid
|
||||
|
||||
|
||||
def _xmluiClose(self):
|
||||
""" Close the window/popup/... where the constructeur XMLUI is
|
||||
this method must be overrided
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@ class MainWindow(wx.Frame, QuickApp):
|
|||
help_string = self.bridge.getMenuHelp(id_, '')
|
||||
current_menu.Append(item_id, name, help=help_string)
|
||||
#now we register the event
|
||||
def event_answer(e):
|
||||
def event_answer(e, id_=id_):
|
||||
self.launchAction(id_, None, profile_key = self.profile)
|
||||
|
||||
wx.EVT_MENU(self, item_id, event_answer)
|
||||
|
|
|
|||
|
|
@ -131,13 +131,6 @@ class ListWidget(EventWidget, WixWidget, xmlui.ListWidget, wx.ListBox):
|
|||
return ret
|
||||
|
||||
|
||||
class AdvancedListWidget(ListWidget):
|
||||
#TODO
|
||||
|
||||
def __init__(self, parent, options, flags):
|
||||
super(ListWidget, self).__init__(parent, options, flags)
|
||||
|
||||
|
||||
class WixContainer(object):
|
||||
_xmlui_proportion = 1
|
||||
|
||||
|
|
@ -185,7 +178,7 @@ class WidgetFactory(object):
|
|||
return cls
|
||||
|
||||
|
||||
class XMLUI(xmlui.XMLUI, wx.Frame, WixContainer):
|
||||
class XMLUI(xmlui.XMLUI, wx.Frame):
|
||||
"""Create an user interface from a SàT XML"""
|
||||
widget_factory = WidgetFactory()
|
||||
|
||||
|
|
@ -199,26 +192,25 @@ class XMLUI(xmlui.XMLUI, wx.Frame, WixContainer):
|
|||
self.sizer = wx.BoxSizer(wx.VERTICAL)
|
||||
self.SetSizer(self.sizer)
|
||||
|
||||
def postTreat(ret_wid):
|
||||
def postTreat():
|
||||
if self.title:
|
||||
self.SetTitle(self.title)
|
||||
|
||||
if self.type == 'form':
|
||||
dialogButtons = wx.StdDialogButtonSizer()
|
||||
submitButton = wx.Button(ret_wid,wx.ID_OK, label=_("Submit"))
|
||||
submitButton = wx.Button(self.main_cont,wx.ID_OK, label=_("Submit"))
|
||||
dialogButtons.AddButton(submitButton)
|
||||
ret_wid.Bind(wx.EVT_BUTTON, self.onFormSubmitted, submitButton)
|
||||
self.main_cont.Bind(wx.EVT_BUTTON, self.onFormSubmitted, submitButton)
|
||||
if not 'NO_CANCEL' in self.flags:
|
||||
cancelButton = wx.Button(ret_wid,wx.ID_CANCEL)
|
||||
cancelButton = wx.Button(self.main_cont,wx.ID_CANCEL)
|
||||
dialogButtons.AddButton(cancelButton)
|
||||
ret_wid.Bind(wx.EVT_BUTTON, self.onFormCancelled, cancelButton)
|
||||
self.main_cont.Bind(wx.EVT_BUTTON, self.onFormCancelled, cancelButton)
|
||||
dialogButtons.Realize()
|
||||
ret_wid.sizer.Add(dialogButtons, flag=wx.ALIGN_CENTER_HORIZONTAL)
|
||||
self.main_cont.sizer.Add(dialogButtons, flag=wx.ALIGN_CENTER_HORIZONTAL)
|
||||
|
||||
self._xmluiAppend(ret_wid)
|
||||
self.sizer.Add(self.main_cont, 1, flag=wx.EXPAND)
|
||||
self.sizer.Fit(self)
|
||||
self.Show()
|
||||
return ret_wid
|
||||
|
||||
super(XMLUI, self).constructUI(xml_data, postTreat)
|
||||
if not 'NO_CANCEL' in self.flags:
|
||||
|
|
@ -251,5 +243,7 @@ class XMLUI(xmlui.XMLUI, wx.Frame, WixContainer):
|
|||
debug(_("close"))
|
||||
if self.type == 'param':
|
||||
self.onSaveParams()
|
||||
else:
|
||||
self._xmluiClose()
|
||||
event.Skip()
|
||||
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ from logging import debug, info, warning, error
|
|||
from twisted.internet import defer, reactor
|
||||
from twisted.words.protocols.jabber import jid
|
||||
from twisted.python.failure import Failure
|
||||
from sat.tools.xml_tools import paramsXml2xmlUI
|
||||
from sat.tools.xml_tools import paramsXML2XMLUI
|
||||
from sat.core.default_config import default_config
|
||||
from sat.memory.sqlite import SqliteStorage
|
||||
from sat.memory.persistent import PersistentDict
|
||||
|
|
@ -130,7 +130,7 @@ class Params(object):
|
|||
<param name="Priority" value="50" type="string" />
|
||||
<param name="Server" value="example.org" type="string" />
|
||||
<param name="Port" value="5222" type="string" />
|
||||
<param name="NewAccount" value="%(label_NewAccount)s" type="button" callback_id="registerNewAccount"/>
|
||||
<param name="NewAccount" label="%(label_NewAccount)s" type="button" callback_id="registerNewAccount"/>
|
||||
<param name="autoconnect" label="%(label_autoconnect)s" value="true" type="bool" />
|
||||
<param name="autodisconnect" label="%(label_autodisconnect)s" value="false" type="bool" />
|
||||
</category>
|
||||
|
|
@ -621,7 +621,7 @@ class Params(object):
|
|||
error(_("Asking params for inexistant profile"))
|
||||
return ""
|
||||
d = self.getParams(security_limit, app, profile)
|
||||
return d.addCallback(lambda param_xml: paramsXml2xmlUI(param_xml))
|
||||
return d.addCallback(lambda param_xml: paramsXML2XMLUI(param_xml))
|
||||
|
||||
def getParams(self, security_limit, app, profile_key):
|
||||
"""Construct xml for asked profile, take params xml as skeleton
|
||||
|
|
|
|||
|
|
@ -234,7 +234,7 @@ class XEP_0050(object):
|
|||
form_ui.addText(_("Please select a command"), 'instructions')
|
||||
|
||||
options = [(item.nodeIdentifier, item.name) for item in items]
|
||||
form_ui.addList(options, "node")
|
||||
form_ui.addList("node", options)
|
||||
return form_ui
|
||||
|
||||
def _commandsAnswer2XMLUI(self, iq_elt, session_id, session_data):
|
||||
|
|
@ -329,7 +329,7 @@ class XEP_0050(object):
|
|||
"""
|
||||
form_ui = xml_tools.XMLUI("form", submit_id=self.__requesting_id)
|
||||
form_ui.addText(_("Please enter target jid"), 'instructions')
|
||||
form_ui.changeLayout("pairs")
|
||||
form_ui.changeContainer("pairs")
|
||||
form_ui.addLabel("jid")
|
||||
form_ui.addString("jid")
|
||||
return {'xmlui': form_ui.toXml()}
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ class XEP_0055(object):
|
|||
"""
|
||||
form_ui = xml_tools.XMLUI("form", title=_("Search directory"), submit_id=self.__menu_cb_id)
|
||||
form_ui.addText(_("Please enter the search jid"), 'instructions')
|
||||
form_ui.changeLayout("pairs")
|
||||
form_ui.changeContainer("pairs")
|
||||
form_ui.addLabel("jid")
|
||||
form_ui.addString("jid", value="users.jabberfr.org") # TODO: replace users.jabberfr.org by any XEP-0055 compatible service discovered on current server
|
||||
return {'xmlui': form_ui.toXml()}
|
||||
|
|
|
|||
|
|
@ -29,9 +29,47 @@ from sat.core import exceptions
|
|||
SAT_FORM_PREFIX = "SAT_FORM_"
|
||||
SAT_PARAM_SEPARATOR = "_XMLUI_PARAM_" # used to have unique elements names
|
||||
|
||||
def dataForm2XMLUI(form, submit_id, session_id=None):
|
||||
"""Take a data form (xep-0004, Wokkel's implementation) and convert it to a SàT xml"""
|
||||
|
||||
# Helper functions
|
||||
|
||||
def _dataFormField2XMLUIData(field):
|
||||
""" Get data needed to create an XMLUI's Widget from Wokkel's data_form's Field
|
||||
@param field: data_form.Field (it uses field.value, field.fieldType, field.label and field.var)
|
||||
@return: widget_type, widget_args, widget_kwargs
|
||||
|
||||
"""
|
||||
widget_args = [field.value]
|
||||
widget_kwargs = {}
|
||||
if field.fieldType == 'fixed' or field.fieldType is None:
|
||||
widget_type = 'text'
|
||||
elif field.fieldType == 'text-single':
|
||||
widget_type = "string"
|
||||
elif field.fieldType == 'text-private':
|
||||
widget_type = "password"
|
||||
elif field.fieldType == 'boolean':
|
||||
widget_type = "bool"
|
||||
if widget_args[0] is None:
|
||||
widget_args[0] = 'false'
|
||||
elif field.fieldType == 'list-single':
|
||||
widget_type = "list"
|
||||
del widget_args[0]
|
||||
widget_kwargs["options"] = [option.value for option in field.options]
|
||||
else:
|
||||
error(u"FIXME FIXME FIXME: Type [%s] is not managed yet by SàT" % field.fieldType)
|
||||
widget_type = "string"
|
||||
|
||||
if field.var:
|
||||
widget_kwargs["name"] = field.var
|
||||
|
||||
return widget_type, widget_args, widget_kwargs
|
||||
|
||||
|
||||
def dataForm2XMLUI(form, submit_id, session_id=None):
|
||||
"""Take a data form (xep-0004, Wokkel's implementation) and convert it to a SàT XML
|
||||
@param submit_id: callback id to call when submitting form
|
||||
@param session_id: id to return with the data
|
||||
|
||||
"""
|
||||
form_ui = XMLUI("form", "vertical", submit_id=submit_id, session_id=session_id)
|
||||
|
||||
if form.instructions:
|
||||
|
|
@ -40,32 +78,18 @@ def dataForm2XMLUI(form, submit_id, session_id=None):
|
|||
labels = [field for field in form.fieldList if field.label]
|
||||
if labels:
|
||||
# if there is no label, we don't need to use pairs
|
||||
form_ui.changeLayout("pairs")
|
||||
form_ui.changeContainer("pairs")
|
||||
|
||||
for field in form.fieldList:
|
||||
if field.fieldType == 'fixed':
|
||||
__field_type = 'text'
|
||||
elif field.fieldType == 'text-single':
|
||||
__field_type = "string"
|
||||
elif field.fieldType == 'text-private':
|
||||
__field_type = "password"
|
||||
elif field.fieldType == 'boolean':
|
||||
__field_type = "bool"
|
||||
if field.value is None:
|
||||
field.value = "false"
|
||||
elif field.fieldType == 'list-single':
|
||||
__field_type = "list"
|
||||
else:
|
||||
error(u"FIXME FIXME FIXME: Type [%s] is not managed yet by SàT" % field.fieldType)
|
||||
__field_type = "string"
|
||||
|
||||
widget_type, widget_args, widget_kwargs = _dataFormField2XMLUIData(field)
|
||||
if labels:
|
||||
if field.label:
|
||||
form_ui.addLabel(field.label)
|
||||
else:
|
||||
form_ui.addEmpty()
|
||||
|
||||
form_ui.addElement(__field_type, field.var, field.value, [option.value for option in field.options])
|
||||
form_ui.addWidget(widget_type, *widget_args, **widget_kwargs)
|
||||
|
||||
return form_ui
|
||||
|
||||
def dataFormResult2AdvancedList(form_ui, form_xml):
|
||||
|
|
@ -75,8 +99,7 @@ def dataFormResult2AdvancedList(form_ui, form_xml):
|
|||
@param form_xml: domish.Element of the data form
|
||||
@return: AdvancedList element
|
||||
"""
|
||||
headers = []
|
||||
items = []
|
||||
headers = {}
|
||||
try:
|
||||
reported_elt = form_xml.elements('jabber:x:data', 'reported').next()
|
||||
except StopIteration:
|
||||
|
|
@ -87,30 +110,28 @@ def dataFormResult2AdvancedList(form_ui, form_xml):
|
|||
raise exceptions.DataError("Unexpected tag")
|
||||
name = elt["var"]
|
||||
label = elt.attributes.get('label','')
|
||||
type_ = elt.attributes.get('type','') # TODO
|
||||
headers.append(Header(name, label))
|
||||
type_ = elt.attributes.get('type')
|
||||
headers[name] = (label, type_)
|
||||
|
||||
if not headers:
|
||||
raise exceptions.DataError("No reported fields (see XEP-0004 §3.4)")
|
||||
|
||||
adv_list = AdvancedListContainer(form_ui, headers=headers, columns=len(headers), parent=form_ui.current_container)
|
||||
form_ui.changeContainer(adv_list)
|
||||
|
||||
item_elts = form_xml.elements('jabber:x:data', 'item')
|
||||
|
||||
for item_elt in item_elts:
|
||||
fields = []
|
||||
for elt in item_elt.elements():
|
||||
if elt.name != 'field':
|
||||
warning("Unexpected tag (%s)" % elt.name)
|
||||
continue
|
||||
name = elt['var']
|
||||
child_elt = elt.firstChildElement()
|
||||
if child_elt.name != "value":
|
||||
raise exceptions.DataError('Was expecting <value> tag')
|
||||
value = unicode(child_elt)
|
||||
fields.append(Field(name, value))
|
||||
items.append(Item(' | '.join((field.value for field in fields if field)), fields))
|
||||
field = data_form.Field.fromElement(elt)
|
||||
|
||||
return form_ui.addAdvancedList(None, headers, items)
|
||||
widget_type, widget_args, widget_kwargs = _dataFormField2XMLUIData(field)
|
||||
form_ui.addWidget(widget_type, *widget_args, **widget_kwargs)
|
||||
|
||||
return form_ui
|
||||
|
||||
def dataFormResult2XMLUI(form_xml, session_id=None):
|
||||
"""Take a raw data form (not parsed by XEP-0004) and convert it to a SàT XMLUI
|
||||
|
|
@ -147,41 +168,57 @@ def tupleList2dataForm(values):
|
|||
|
||||
return form
|
||||
|
||||
def paramsXml2xmlUI(xml):
|
||||
def paramsXML2XMLUI(xml):
|
||||
"""Convert the xml for parameter to a SàT XML User Interface"""
|
||||
params_doc = minidom.parseString(xml.encode('utf-8'))
|
||||
top = params_doc.documentElement
|
||||
if top.nodeName != 'params':
|
||||
error(_('INTERNAL ERROR: parameters xml not valid'))
|
||||
assert(False)
|
||||
raise exceptions.DataError(_('INTERNAL ERROR: parameters xml not valid'))
|
||||
|
||||
param_ui = XMLUI("param", "tabs")
|
||||
tabs_cont = param_ui.current_container
|
||||
|
||||
for category in top.getElementsByTagName("category"):
|
||||
category_name = category.getAttribute('name')
|
||||
label = category.getAttribute('label')
|
||||
if not category_name:
|
||||
error(_('INTERNAL ERROR: params categories must have a name'))
|
||||
assert(False)
|
||||
param_ui.addCategory(category_name, 'pairs', label=label)
|
||||
raise exceptions.DataError(_('INTERNAL ERROR: params categories must have a name'))
|
||||
tabs_cont.addTab(category_name, label=label, container=PairsContainer)
|
||||
for param in category.getElementsByTagName("param"):
|
||||
widget_kwargs = {}
|
||||
|
||||
param_name = param.getAttribute('name')
|
||||
label = param.getAttribute('label')
|
||||
param_label = param.getAttribute('label')
|
||||
if not param_name:
|
||||
error(_('INTERNAL ERROR: params must have a name'))
|
||||
assert(False)
|
||||
raise exceptions.DataError(_('INTERNAL ERROR: params must have a name'))
|
||||
|
||||
type_ = param.getAttribute('type')
|
||||
value = param.getAttribute('value') or None
|
||||
options = getOptions(param)
|
||||
callback_id = param.getAttribute('callback_id') or None
|
||||
|
||||
if type_ == 'list':
|
||||
options = _getParamListOptions(param)
|
||||
widget_kwargs['options'] = options
|
||||
|
||||
if type_ == "button":
|
||||
param_ui.addEmpty()
|
||||
else:
|
||||
param_ui.addLabel(label or param_name)
|
||||
param_ui.addElement(name="%s%s%s" % (category_name, SAT_PARAM_SEPARATOR, param_name), type_=type_, value=value, options=options, callback_id=callback_id)
|
||||
param_ui.addLabel(param_label or param_name)
|
||||
|
||||
if value:
|
||||
widget_kwargs["value"] = value
|
||||
|
||||
if callback_id:
|
||||
widget_kwargs['callback_id'] = callback_id
|
||||
|
||||
widget_kwargs['name'] = "%s%s%s" % (category_name, SAT_PARAM_SEPARATOR, param_name)
|
||||
|
||||
param_ui.addWidget(type_, **widget_kwargs)
|
||||
|
||||
return param_ui.toXml()
|
||||
|
||||
|
||||
def getOptions(param):
|
||||
def _getParamListOptions(param):
|
||||
"""Retrieve the options for list element. Allow listing the <option/>
|
||||
tags directly in <param/> or in an intermediate <options/> tag."""
|
||||
elems = param.getElementsByTagName("options")
|
||||
|
|
@ -194,60 +231,349 @@ def getOptions(param):
|
|||
return [elem.getAttribute("value") for elem in elems]
|
||||
|
||||
|
||||
class Header(object):
|
||||
"""AdvandeList's header"""
|
||||
## XMLUI Elements
|
||||
|
||||
def __init__(self, field_name, label, description=None, type_=None):
|
||||
|
||||
class Element(object):
|
||||
""" Base XMLUI element """
|
||||
type = None
|
||||
|
||||
def __init__(self, xmlui, parent=None):
|
||||
"""Create a container element
|
||||
@param xmlui: XMLUI instance
|
||||
@parent: parent element
|
||||
"""
|
||||
@param field_name: name of the field referenced
|
||||
assert(self.type) is not None
|
||||
if not hasattr(self, 'elem'):
|
||||
self.elem = parent.xmlui.doc.createElement(self.type)
|
||||
self.xmlui = xmlui
|
||||
if parent is not None:
|
||||
parent.append(self)
|
||||
else:
|
||||
self.parent = parent
|
||||
|
||||
def append(self, child):
|
||||
self.elem.appendChild(child.elem)
|
||||
child.parent = self
|
||||
|
||||
|
||||
class TopElement(Element):
|
||||
""" Main XML Element """
|
||||
type = 'top'
|
||||
|
||||
def __init__(self, xmlui):
|
||||
self.elem = xmlui.doc.documentElement
|
||||
super(TopElement, self).__init__(xmlui)
|
||||
|
||||
|
||||
class TabElement(Element):
|
||||
""" Used by TabsContainer to give name and label to tabs """
|
||||
type = 'tab'
|
||||
|
||||
def __init__(self, parent, name, label):
|
||||
if not isinstance(parent, TabsContainer):
|
||||
raise exceptions.DataError(_("TabElement must be a child of TabsContainer"))
|
||||
super(TabElement, self).__init__(parent.xmlui, parent)
|
||||
self.elem.setAttribute('name', name)
|
||||
self.elem.setAttribute('label', label)
|
||||
|
||||
|
||||
class FieldBackElement(Element):
|
||||
""" Used by ButtonWidget to indicate which field have to be sent back """
|
||||
type = 'field_back'
|
||||
|
||||
def __init__(self, parent, name):
|
||||
assert(isinstance(parent, ButtonWidget))
|
||||
super(FieldBackElement, self).__init__(parent.xmlui, parent)
|
||||
self.elem.setAttribute('name', name)
|
||||
|
||||
|
||||
class OptionElement(Element):
|
||||
"""" Used by ListWidget to specify options """
|
||||
type = 'option'
|
||||
|
||||
def __init__(self, parent, option):
|
||||
assert(isinstance(parent, ListWidget))
|
||||
super(OptionElement, self).__init__(parent.xmlui, parent)
|
||||
if isinstance(option, basestring):
|
||||
value, label = option, option
|
||||
elif isinstance(option, tuple):
|
||||
value, label = option
|
||||
self.elem.setAttribute('value', value)
|
||||
self.elem.setAttribute('label', label)
|
||||
|
||||
|
||||
class RowElement(Element):
|
||||
"""" Used by AdvancedListContainer """
|
||||
type = 'row'
|
||||
|
||||
def __init__(self, parent):
|
||||
assert(isinstance(parent, AdvancedListContainer))
|
||||
super(RowElement, self).__init__(parent.xmlui, parent)
|
||||
|
||||
|
||||
class HeaderElement(Element):
|
||||
"""" Used by AdvancedListContainer """
|
||||
type = 'header'
|
||||
|
||||
def __init__(self, parent, name=None, Label=None, description=None):
|
||||
"""
|
||||
@param parent: AdvancedListContainer instance
|
||||
@param name: name of the container
|
||||
@param label: label to be displayed in columns
|
||||
@param description: long descriptive text
|
||||
@param type_: TODO
|
||||
|
||||
"""
|
||||
self.field_name = field_name
|
||||
self.label = label
|
||||
self.description = description
|
||||
self.type = type_
|
||||
if type_ is not None:
|
||||
raise NotImplementedError # TODO:
|
||||
assert(isinstance(parent, AdvancedListContainer))
|
||||
super(HeaderElement, self).__init__(parent.xmlui, parent)
|
||||
if name:
|
||||
field_elt.setAttribute('name', name)
|
||||
if label:
|
||||
field_elt.setAttribute('label', label)
|
||||
if description:
|
||||
field_elt.setAttribute('description', description)
|
||||
|
||||
|
||||
class Item(object):
|
||||
"""Item used in AdvancedList"""
|
||||
class Container(Element):
|
||||
""" And Element which contains other ones and has a layout """
|
||||
type = None
|
||||
|
||||
def __init__(self, text=None, fields=None):
|
||||
def __init__(self, xmlui, parent=None):
|
||||
"""Create a container element
|
||||
@param xmlui: XMLUI instance
|
||||
@parent: parent element or None
|
||||
"""
|
||||
@param text: Optional textual representation, when fields are not showed individually
|
||||
@param fields: list of Field instances²
|
||||
self.elem = xmlui.doc.createElement('container')
|
||||
super(Container, self).__init__(xmlui, parent)
|
||||
self.elem.setAttribute('type', self.type)
|
||||
|
||||
def getParentContainer(self):
|
||||
""" Return first parent container
|
||||
@return: parent container or None
|
||||
|
||||
"""
|
||||
self.text = text
|
||||
self.fields = fields if fields is not None else []
|
||||
current = self.parent
|
||||
while(not isinstance(current, (Container)) and
|
||||
current is not None):
|
||||
current = current.parent
|
||||
return current
|
||||
|
||||
class VerticalContainer(Container):
|
||||
type = "vertical"
|
||||
|
||||
|
||||
class Field(object):
|
||||
"""Field used in AdvancedList (in items)"""
|
||||
class HorizontalContainer(Container):
|
||||
type = "horizontal"
|
||||
|
||||
|
||||
class PairsContainer(Container):
|
||||
type = "pairs"
|
||||
|
||||
|
||||
class TabsContainer(Container):
|
||||
type = "tabs"
|
||||
|
||||
def addTab(self, name, label=None, container=VerticalContainer):
|
||||
"""Add a tab"""
|
||||
if not label:
|
||||
label = name
|
||||
tab_elt = TabElement(self, name, label)
|
||||
new_container = container(self.xmlui, tab_elt)
|
||||
self.xmlui.changeContainer(new_container)
|
||||
|
||||
def end(self):
|
||||
""" Called when we have finished tabs
|
||||
change current container to first container parent
|
||||
|
||||
def __init__(self, name, value):
|
||||
"""
|
||||
@param name: name of the field, used to identify the field in headers
|
||||
@param value: actual content of the field
|
||||
"""
|
||||
self.name = name
|
||||
self.value = value
|
||||
parent_container = self.getParentContainer()
|
||||
self.xmlui.changeContainer(parent_container)
|
||||
|
||||
|
||||
class AdvancedListContainer(Container):
|
||||
type = "advanced_list"
|
||||
|
||||
def __init__(self, xmlui, name=None, headers=None, items=None, columns=None, parent=None):
|
||||
"""Create an advanced list
|
||||
@param headers: optional headers informations
|
||||
@param items: list of Item instances
|
||||
@return: created element
|
||||
"""
|
||||
if not items and columns is None:
|
||||
raise DataError(_("either items or columns need do be filled"))
|
||||
if headers is None:
|
||||
headers = []
|
||||
if items is None:
|
||||
items = []
|
||||
super(AdvancedListContainer, self).__init__(xmlui, parent)
|
||||
if columns is None:
|
||||
columns = len(items[0])
|
||||
self._columns = columns
|
||||
self._current_column = 0
|
||||
self.current_row = None
|
||||
if headers:
|
||||
if len(headers) != self._columns:
|
||||
raise exceptions.DataError(_("Headers lenght doesn't correspond to columns"))
|
||||
self.addHeaders(headers)
|
||||
if items:
|
||||
self.addItems(items)
|
||||
|
||||
def addHeaders(self, headers):
|
||||
for header in headers:
|
||||
self.addHeader(header)
|
||||
|
||||
def addHeader(self, header):
|
||||
pass # TODO
|
||||
|
||||
def addItems(self, items):
|
||||
for item in items:
|
||||
self.addItem(item)
|
||||
|
||||
def addItem(self, item):
|
||||
if self._current_column % self._columns == 0:
|
||||
self.current_row = RowElement(self)
|
||||
self.current_row.append(item)
|
||||
|
||||
def end(self):
|
||||
""" Called when we have finished list
|
||||
change current container to first container parent
|
||||
|
||||
"""
|
||||
if self._current_colum % self._columns != 0:
|
||||
raise exceptions.DataError(_("Incorrect number of items in list"))
|
||||
parent_container = self.getParentContainer()
|
||||
self.xmlui.changeContainer(parent_container)
|
||||
|
||||
|
||||
class Widget(Element):
|
||||
type = None
|
||||
|
||||
def __init__(self, xmlui, name=None, parent=None):
|
||||
"""Create an element
|
||||
@param xmlui: XMLUI instance
|
||||
@param name: name of the element or None
|
||||
@param parent: parent element or None
|
||||
"""
|
||||
self.elem = xmlui.doc.createElement('widget')
|
||||
super(Widget, self).__init__(xmlui, parent)
|
||||
if name:
|
||||
self.elem.setAttribute('name', name)
|
||||
self.elem.setAttribute('type', self.type)
|
||||
|
||||
|
||||
class InputWidget(Widget):
|
||||
pass
|
||||
|
||||
|
||||
class EmptyWidget(Widget):
|
||||
type = 'empty'
|
||||
|
||||
|
||||
class TextWidget(Widget):
|
||||
type = 'text'
|
||||
|
||||
def __init__(self, xmlui, text, name=None, parent=None):
|
||||
super(TextWidget, self).__init__(xmlui, name, parent)
|
||||
text = self.xmlui.doc.createTextNode(text)
|
||||
self.elem.appendChild(text)
|
||||
|
||||
|
||||
class LabelWidget(Widget):
|
||||
type='label'
|
||||
|
||||
def __init__(self, xmlui, label, name=None, parent=None):
|
||||
super(LabelWidget, self).__init__(xmlui, name, parent)
|
||||
self.elem.setAttribute('value', label)
|
||||
|
||||
|
||||
class StringWidget(InputWidget):
|
||||
type = 'string'
|
||||
|
||||
def __init__(self, xmlui, value=None, name=None, parent=None):
|
||||
super(StringWidget, self).__init__(xmlui, name, parent)
|
||||
if value:
|
||||
self.elem.setAttribute('value', value)
|
||||
|
||||
|
||||
class PasswordWidget(StringWidget):
|
||||
type = 'password'
|
||||
|
||||
|
||||
class TextBoxWidget(StringWidget):
|
||||
type = 'textbox'
|
||||
|
||||
|
||||
class BoolWidget(InputWidget):
|
||||
type = 'bool'
|
||||
|
||||
def __init__(self, xmlui, value='false', name=None, parent=None):
|
||||
if value == '0':
|
||||
value='false'
|
||||
elif value == '1':
|
||||
value='true'
|
||||
if not value in ('true', 'false'):
|
||||
raise exceptions.DataError(_("Value must be 0, 1, false or true"))
|
||||
super(BoolWidget, self).__init__(xmlui, name, parent)
|
||||
self.elem.setAttribute('value', value)
|
||||
|
||||
|
||||
class ButtonWidget(InputWidget):
|
||||
type = 'button'
|
||||
|
||||
def __init__(self, xmlui, callback_id, value=None, fields_back=None, name=None, parent=None):
|
||||
"""Add a button
|
||||
@param callback_id: callback which will be called if button is pressed
|
||||
@param value: label of the button
|
||||
@fields_back: list of names of field to give back when pushing the button
|
||||
@param name: name
|
||||
@param parent: parent container
|
||||
"""
|
||||
if fields_back is None:
|
||||
fields_back = []
|
||||
super(ButtonWidget, self).__init__(xmlui, name, parent)
|
||||
self.elem.setAttribute('callback', callback_id)
|
||||
if value:
|
||||
self.elem.setAttribute('value', value)
|
||||
for field in fields_back:
|
||||
fback_el = FieldBackElement(self, field)
|
||||
|
||||
|
||||
class ListWidget(InputWidget):
|
||||
type = 'list'
|
||||
|
||||
def __init__(self, xmlui, options, value=None, style=None, name=None, parent=None):
|
||||
if style is None:
|
||||
style = set()
|
||||
styles = set(style)
|
||||
assert options
|
||||
if not styles.issubset(['multi']):
|
||||
raise exceptions.DataError(_("invalid styles"))
|
||||
super(ListWidget, self).__init__(xmlui, name, parent)
|
||||
self.addOptions(options)
|
||||
if value:
|
||||
self.elem.setAttribute('value', value)
|
||||
for style in styles:
|
||||
self.elem.setAttribute(style, 'yes')
|
||||
|
||||
def addOptions(self, options):
|
||||
"""i Add options to a multi-values element (e.g. list) """
|
||||
for option in options:
|
||||
OptionElement(self, option)
|
||||
|
||||
|
||||
## XMLUI main class
|
||||
|
||||
|
||||
class XMLUI(object):
|
||||
"""This class is used to create a user interface (form/window/parameters/etc) using SàT XML"""
|
||||
|
||||
def __init__(self, panel_type, layout="vertical", title=None, submit_id=None, session_id=None):
|
||||
def __init__(self, panel_type, container="vertical", title=None, submit_id=None, session_id=None):
|
||||
"""Init SàT XML Panel
|
||||
@param panel_type: one of
|
||||
- window (new window)
|
||||
- form (formulaire, depend of the frontend, usually a panel with cancel/submit buttons)
|
||||
- param (parameters, presentatio depend of the frontend)
|
||||
@param layout: disposition of elements, one of:
|
||||
- param (parameters, presentation depend of the frontend)
|
||||
@param container: disposition of elements, one of:
|
||||
- vertical: elements are disposed up to bottom
|
||||
- horizontal: elements are disposed left to right
|
||||
- pairs: elements come on two aligned columns
|
||||
|
|
@ -256,11 +582,14 @@ class XMLUI(object):
|
|||
@param title: title or default if None
|
||||
@param submit_id: callback id to call for panel_type we can submit (form, param)
|
||||
"""
|
||||
self._introspect()
|
||||
if panel_type not in ['window', 'form', 'param']:
|
||||
raise exceptions.DataError(_("Unknown panel type [%s]") % panel_type)
|
||||
if panel_type == 'form' and submit_id is None:
|
||||
raise exceptions.DataError(_("form XMLUI need a submit_id"))
|
||||
self.type_ = panel_type
|
||||
if not isinstance(container, basestring):
|
||||
raise exceptions.DataError(_("container argument must be a string"))
|
||||
self.type = panel_type
|
||||
impl = minidom.getDOMImplementation()
|
||||
|
||||
self.doc = impl.createDocument(None, "sat_xmlui", None)
|
||||
|
|
@ -270,14 +599,45 @@ class XMLUI(object):
|
|||
top_element.setAttribute("title", title)
|
||||
self.submit_id = submit_id
|
||||
self.session_id = session_id
|
||||
self.parentTabsLayout = None # used only we have 'tabs' layout
|
||||
self.currentCategory = None # used only we have 'tabs' layout
|
||||
self.currentLayout = None
|
||||
self.changeLayout(layout)
|
||||
self.main_container = self._createContainer(container, TopElement(self))
|
||||
self.current_container = self.main_container
|
||||
|
||||
def _introspect(self):
|
||||
""" Introspect module to find Widgets and Containers """
|
||||
self._containers = {}
|
||||
self._widgets = {}
|
||||
for obj in globals().values():
|
||||
try:
|
||||
if issubclass(obj, Widget):
|
||||
if obj.__name__ == 'Widget':
|
||||
continue
|
||||
self._widgets[obj.type] = obj
|
||||
elif issubclass(obj, Container):
|
||||
if obj.__name__ == 'Container':
|
||||
continue
|
||||
self._containers[obj.type] = obj
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
def __del__(self):
|
||||
self.doc.unlink()
|
||||
|
||||
def __getattr__(self, name):
|
||||
if name.startswith("add") and name not in ('addWidget',): # addWidgetName(...) create an instance of WidgetName
|
||||
class_name = name[3:]+"Widget"
|
||||
if class_name in globals():
|
||||
cls = globals()[class_name]
|
||||
if issubclass(cls, Widget):
|
||||
def createWidget(*args, **kwargs):
|
||||
if "parent" not in kwargs:
|
||||
kwargs["parent"] = self.current_container
|
||||
if "name" not in kwargs and issubclass(cls, InputWidget): # name can be given as first argument or in keyword arguments for InputWidgets
|
||||
args = list(args)
|
||||
kwargs["name"] = args.pop(0)
|
||||
return cls(self, *args, **kwargs)
|
||||
return createWidget
|
||||
return object.__getattribute__(self, name)
|
||||
|
||||
@property
|
||||
def submit_id(self):
|
||||
top_element = self.doc.documentElement
|
||||
|
|
@ -314,242 +674,45 @@ class XMLUI(object):
|
|||
else:
|
||||
raise exceptions.DataError("session_id can't be empty")
|
||||
|
||||
def _createLayout(self, layout, parent=None):
|
||||
"""Create a layout element
|
||||
@param type: layout type (cf init doc)
|
||||
def _createContainer(self, container, parent=None, **kwargs):
|
||||
"""Create a container element
|
||||
@param type: container type (cf init doc)
|
||||
@parent: parent element or None
|
||||
"""
|
||||
if not layout in ['vertical', 'horizontal', 'pairs', 'tabs']:
|
||||
error(_("Unknown layout type [%s]") % layout)
|
||||
assert False
|
||||
layout_elt = self.doc.createElement('layout')
|
||||
layout_elt.setAttribute('type', layout)
|
||||
if parent is not None:
|
||||
parent.appendChild(layout_elt)
|
||||
return layout_elt
|
||||
if container not in self._containers:
|
||||
raise exceptions.DataError(_("Unknown container type [%s]") % container)
|
||||
cls = self._containers[container]
|
||||
new_container = cls(self, parent, **kwargs)
|
||||
return new_container
|
||||
|
||||
def _createElem(self, type_, name=None, parent=None):
|
||||
"""Create an element
|
||||
@param type_: one of
|
||||
- empty: empty element (usefull to skip something in a layout, e.g. skip first element in a PAIRS layout)
|
||||
- text: text to be displayed in an multi-line area, e.g. instructions
|
||||
@param name: name of the element or None
|
||||
@param parent: parent element or None
|
||||
@return: created element
|
||||
"""
|
||||
elem = self.doc.createElement('elem')
|
||||
if name:
|
||||
elem.setAttribute('name', name)
|
||||
elem.setAttribute('type', type_)
|
||||
if parent is not None:
|
||||
parent.appendChild(elem)
|
||||
return elem
|
||||
def changeContainer(self, container, **kwargs):
|
||||
"""Change the current container
|
||||
@param container: either container type (container it then created),
|
||||
or an Container instance"""
|
||||
if isinstance(container, basestring):
|
||||
self.current_container = self._createContainer(container, self.current_container.getParentContainer() or self.main_container, **kwargs)
|
||||
else:
|
||||
self.current_container = self.main_container if container is None else container
|
||||
assert(isinstance(self.current_container, Container))
|
||||
return self.current_container
|
||||
|
||||
def changeLayout(self, layout):
|
||||
"""Change the current layout"""
|
||||
self.currentLayout = self._createLayout(layout, self.currentCategory if self.currentCategory else self.doc.documentElement)
|
||||
if layout == "tabs":
|
||||
self.parentTabsLayout = self.currentLayout
|
||||
|
||||
def addEmpty(self, name=None):
|
||||
"""Add a multi-lines text"""
|
||||
return self._createElem('empty', name, self.currentLayout)
|
||||
|
||||
def addText(self, text, name=None):
|
||||
"""Add a multi-lines text"""
|
||||
elem = self._createElem('text', name, self.currentLayout)
|
||||
text = self.doc.createTextNode(text)
|
||||
elem.appendChild(text)
|
||||
return elem
|
||||
|
||||
def addLabel(self, text, name=None):
|
||||
"""Add a single line text, mainly useful as label before element"""
|
||||
elem = self._createElem('label', name, self.currentLayout)
|
||||
elem.setAttribute('value', text)
|
||||
return elem
|
||||
|
||||
def addString(self, name=None, value=None):
|
||||
"""Add a string box"""
|
||||
elem = self._createElem('string', name, self.currentLayout)
|
||||
if value:
|
||||
elem.setAttribute('value', value)
|
||||
return elem
|
||||
|
||||
def addPassword(self, name=None, value=None):
|
||||
"""Add a password box"""
|
||||
elem = self._createElem('password', name, self.currentLayout)
|
||||
if value:
|
||||
elem.setAttribute('value', value)
|
||||
return elem
|
||||
|
||||
def addTextBox(self, name=None, value=None):
|
||||
"""Add a string box"""
|
||||
elem = self._createElem('textbox', name, self.currentLayout)
|
||||
if value:
|
||||
elem.setAttribute('value', value)
|
||||
return elem
|
||||
|
||||
def addBool(self, name=None, value="true"):
|
||||
"""Add a string box"""
|
||||
if value=="0":
|
||||
value="false"
|
||||
elif value=="1":
|
||||
value="true"
|
||||
assert value in ["true", "false"]
|
||||
elem = self._createElem('bool', name, self.currentLayout)
|
||||
elem.setAttribute('value', value)
|
||||
return elem
|
||||
|
||||
def addList(self, options, name=None, value=None, style=None):
|
||||
"""Add a list of choices"""
|
||||
if style is None:
|
||||
style = set()
|
||||
styles = set(style)
|
||||
assert options
|
||||
assert styles.issubset(['multi'])
|
||||
elem = self._createElem('list', name, self.currentLayout)
|
||||
self.addOptions(options, elem)
|
||||
if value:
|
||||
elem.setAttribute('value', value)
|
||||
for style in styles:
|
||||
elem.setAttribute(style, 'yes')
|
||||
return elem
|
||||
|
||||
def addAdvancedList(self, name=None, headers=None, items=None):
|
||||
"""Create an advanced list
|
||||
@param headers: optional headers informations
|
||||
@param items: list of Item instances
|
||||
@return: created element
|
||||
"""
|
||||
elem = self._createElem('advanced_list', name, self.currentLayout)
|
||||
self.addHeaders(headers, elem)
|
||||
if items:
|
||||
self.addItems(items, elem)
|
||||
return elem
|
||||
|
||||
def addButton(self, callback_id, name, value, fields_back=[]):
|
||||
"""Add a button
|
||||
@param callback: callback which will be called if button is pressed
|
||||
@param name: name
|
||||
@param value: label of the button
|
||||
@fields_back: list of names of field to give back when pushing the button
|
||||
"""
|
||||
elem = self._createElem('button', name, self.currentLayout)
|
||||
elem.setAttribute('callback', callback_id)
|
||||
elem.setAttribute('value', value)
|
||||
for field in fields_back:
|
||||
fback_el = self.doc.createElement('field_back')
|
||||
fback_el.setAttribute('name', field)
|
||||
elem.appendChild(fback_el)
|
||||
return elem
|
||||
|
||||
def addElement(self, type_, name=None, value=None, options=None, callback_id=None, headers=None, available=None):
|
||||
"""Convenience method to add element, the params correspond to the ones in addSomething methods"""
|
||||
if type_ == 'empty':
|
||||
return self.addEmpty(name)
|
||||
elif type_ == 'text':
|
||||
assert value is not None
|
||||
return self.addText(value, name)
|
||||
elif type_ == 'label':
|
||||
assert(value)
|
||||
return self.addLabel(value)
|
||||
elif type_ == 'string':
|
||||
return self.addString(name, value)
|
||||
elif type_ == 'password':
|
||||
return self.addPassword(name, value)
|
||||
elif type_ == 'textbox':
|
||||
return self.addTextBox(name, value)
|
||||
elif type_ == 'bool':
|
||||
if not value:
|
||||
value = "true"
|
||||
return self.addBool(name, value)
|
||||
elif type_ == 'list':
|
||||
return self.addList(options, name, value)
|
||||
elif type_ == 'advancedlist':
|
||||
return self.addAdvancedList(name, headers, available)
|
||||
elif type_ == 'button':
|
||||
assert(callback_id and value)
|
||||
return self.addButton(callback_id, name, value)
|
||||
|
||||
# List
|
||||
|
||||
def addOptions(self, options, parent):
|
||||
"""Add options to a multi-values element (e.g. list)
|
||||
@param parent: multi-values element"""
|
||||
for option in options:
|
||||
opt = self.doc.createElement('option')
|
||||
if isinstance(option, basestring):
|
||||
value, label = option, option
|
||||
elif isinstance(option, tuple):
|
||||
value, label = option
|
||||
opt.setAttribute('value', value)
|
||||
opt.setAttribute('label', label)
|
||||
parent.appendChild(opt)
|
||||
|
||||
# Advanced list
|
||||
|
||||
def addHeaders(self, headers, parent):
|
||||
headers_elt = self.doc.createElement('headers')
|
||||
for header in headers:
|
||||
field_elt = self.doc.createElement('field')
|
||||
field_elt.setAttribute('field_name', header.field_name)
|
||||
field_elt.setAttribute('label', header.label)
|
||||
if header.description:
|
||||
field_elt.setAttribute('description', header.description)
|
||||
if header.type:
|
||||
field_elt.setAttribute('type', header.type)
|
||||
headers_elt.appendChild(field_elt)
|
||||
parent.appendChild(headers_elt)
|
||||
|
||||
def addItems(self, items, parent):
|
||||
"""Add items to an AdvancedList
|
||||
@param items: list of Item instances
|
||||
@param parent: parent element (should be addAdvancedList)
|
||||
|
||||
"""
|
||||
items_elt = self.doc.createElement('items')
|
||||
for item in items:
|
||||
item_elt = self.doc.createElement('item')
|
||||
if item.text is not None:
|
||||
text_elt = self.doc.createElement('text')
|
||||
text_elt.appendChild(self.doc.createTextNode(item.text))
|
||||
item_elt.appendChild(text_elt)
|
||||
|
||||
for field in item.fields:
|
||||
field_elt = self.doc.createElement('field')
|
||||
field_elt.setAttribute('name', field.name)
|
||||
field_elt.setAttribute('value', field.value)
|
||||
item_elt.appendChild(field_elt)
|
||||
|
||||
items_elt.appendChild(item_elt)
|
||||
|
||||
parent.appendChild(items_elt)
|
||||
|
||||
# Tabs
|
||||
|
||||
def addCategory(self, name, layout, label=None):
|
||||
"""Add a category to current layout (must be a tabs layout)"""
|
||||
assert(layout != 'tabs')
|
||||
if not self.parentTabsLayout:
|
||||
error(_("Trying to add a category without parent tabs layout"))
|
||||
assert(False)
|
||||
if self.parentTabsLayout.getAttribute('type') != 'tabs':
|
||||
error(_("parent layout of a category is not tabs"))
|
||||
assert(False)
|
||||
|
||||
if not label:
|
||||
label = name
|
||||
self.currentCategory = cat = self.doc.createElement('category')
|
||||
cat.setAttribute('name', name)
|
||||
cat.setAttribute('label', label)
|
||||
self.changeLayout(layout)
|
||||
self.parentTabsLayout.appendChild(cat)
|
||||
def addWidget(self, type_, *args, **kwargs):
|
||||
"""Convenience method to add an element"""
|
||||
if type_ not in self._widgets:
|
||||
raise exceptions.DataError(_("Invalid type [%s]") % type_)
|
||||
if "parent" not in kwargs:
|
||||
kwargs["parent"] = self.current_container
|
||||
cls = self._widgets[type_]
|
||||
return cls(self, *args, **kwargs)
|
||||
|
||||
def toXml(self):
|
||||
"""return the XML representation of the panel"""
|
||||
return self.doc.toxml()
|
||||
|
||||
|
||||
# Misc other funtions
|
||||
|
||||
|
||||
class ElementParser(object):
|
||||
"""callable class to parse XML string into Element
|
||||
Found at http://stackoverflow.com/questions/2093400/how-to-create-twisted-words-xish-domish-element-entirely-from-raw-xml/2095942#2095942
|
||||
|
|
|
|||
Loading…
Reference in a new issue