# HG changeset patch
# User Goffi <goffi@goffi.org>
# Date 1391534340 -3600
# Node ID 9007bb1330097b9dbb792efdb66244703e9b9abe
# Parent  02ee9ef952770ca12ffb2b10170fb0e609b9a3a4
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

diff -r 02ee9ef95277 -r 9007bb133009 frontends/src/primitivus/xmlui.py
--- a/frontends/src/primitivus/xmlui.py	Tue Feb 04 18:06:12 2014 +0100
+++ b/frontends/src/primitivus/xmlui.py	Tue Feb 04 18:19:00 2014 +0100
@@ -103,12 +103,6 @@
         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 PrimitivusVerticalContainer(xmlui.VerticalContainer, urwid.ListBox):
 
-
     def __init__(self, parent):
         urwid.ListBox.__init__(self, urwid.SimpleListWalker([]))
 
@@ -169,13 +162,14 @@
     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 @@
                     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
diff -r 02ee9ef95277 -r 9007bb133009 frontends/src/tools/xmlui.py
--- a/frontends/src/tools/xmlui.py	Tue Feb 04 18:06:12 2014 +0100
+++ b/frontends/src/tools/xmlui.py	Tue Feb 04 18:19:00 2014 +0100
@@ -89,9 +89,6 @@
     """ 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 @@
             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 @@
                     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 @@
         @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 @@
         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
diff -r 02ee9ef95277 -r 9007bb133009 frontends/src/wix/main_window.py
--- a/frontends/src/wix/main_window.py	Tue Feb 04 18:06:12 2014 +0100
+++ b/frontends/src/wix/main_window.py	Tue Feb 04 18:19:00 2014 +0100
@@ -160,7 +160,7 @@
             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)
diff -r 02ee9ef95277 -r 9007bb133009 frontends/src/wix/xmlui.py
--- a/frontends/src/wix/xmlui.py	Tue Feb 04 18:06:12 2014 +0100
+++ b/frontends/src/wix/xmlui.py	Tue Feb 04 18:19:00 2014 +0100
@@ -131,13 +131,6 @@
         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 @@
             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 @@
         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 @@
         debug(_("close"))
         if self.type == 'param':
             self.onSaveParams()
+        else:
+            self._xmluiClose()
         event.Skip()
 
diff -r 02ee9ef95277 -r 9007bb133009 src/memory/memory.py
--- a/src/memory/memory.py	Tue Feb 04 18:06:12 2014 +0100
+++ b/src/memory/memory.py	Tue Feb 04 18:19:00 2014 +0100
@@ -29,7 +29,7 @@
 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 @@
             <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 @@
             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
diff -r 02ee9ef95277 -r 9007bb133009 src/plugins/plugin_xep_0050.py
--- a/src/plugins/plugin_xep_0050.py	Tue Feb 04 18:06:12 2014 +0100
+++ b/src/plugins/plugin_xep_0050.py	Tue Feb 04 18:19:00 2014 +0100
@@ -234,7 +234,7 @@
         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 @@
         """
         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()}
diff -r 02ee9ef95277 -r 9007bb133009 src/plugins/plugin_xep_0055.py
--- a/src/plugins/plugin_xep_0055.py	Tue Feb 04 18:06:12 2014 +0100
+++ b/src/plugins/plugin_xep_0055.py	Tue Feb 04 18:19:00 2014 +0100
@@ -75,7 +75,7 @@
         """
         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()}
diff -r 02ee9ef95277 -r 9007bb133009 src/tools/xml_tools.py
--- a/src/tools/xml_tools.py	Tue Feb 04 18:06:12 2014 +0100
+++ b/src/tools/xml_tools.py	Tue Feb 04 18:19:00 2014 +0100
@@ -29,9 +29,47 @@
 SAT_FORM_PREFIX = "SAT_FORM_"
 SAT_PARAM_SEPARATOR = "_XMLUI_PARAM_" # used to have unique elements names
 
+
+# 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"""
+    """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 @@
     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 @@
     @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 @@
             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 @@
 
     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 @@
     return [elem.getAttribute("value") for elem in elems]
 
 
-class Header(object):
-    """AdvandeList's header"""
+## XMLUI Elements
+
+
+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
+        """
+        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, field_name, label, description=None, type_=None):
+    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 field_name: name of the field referenced
+        @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
+
+        """
+        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 Container(Element):
+    """ And Element which contains other ones and has a layout """
+    type = None
+
+    def __init__(self, xmlui, parent=None):
+        """Create a container element
+        @param xmlui: XMLUI instance
+        @parent: parent element or None
+        """
+        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.field_name = field_name
-        self.label = label
-        self.description = description
-        self.type = type_
-        if type_ is not None:
-            raise NotImplementedError # TODO:
+        current = self.parent
+        while(not isinstance(current, (Container)) and
+              current is not None):
+            current = current.parent
+        return current
+
+class VerticalContainer(Container):
+    type = "vertical"
+
+
+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
+
+        """
+        parent_container = self.getParentContainer()
+        self.xmlui.changeContainer(parent_container)
 
 
-class Item(object):
-    """Item used in AdvancedList"""
+class AdvancedListContainer(Container):
+    type = "advanced_list"
 
-    def __init__(self, text=None, fields=None):
+    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
         """
-        @param text: Optional textual representation, when fields are not showed individually
-        @param fields: list of Field instances²
+        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
+
         """
-        self.text = text
-        self.fields = fields if fields is not None else []
+        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 Field(object):
-    """Field used in AdvancedList (in items)"""
+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'
 
-    def __init__(self, name, value):
+
+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
         """
-        @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
+        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 @@
         @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 @@
             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 @@
         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
-
-    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 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
+        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 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)
+    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
 
-    # 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