Index: in/waeup.sirp/branches/ulif-fasttables/src/waeup/sirp/jambtables/dictwidget.pt
===================================================================
--- /main/waeup.sirp/branches/ulif-fasttables/src/waeup/sirp/jambtables/dictwidget.pt	(revision 5296)
+++ 	(revision )
@@ -1,46 +1,0 @@
-<table border="0" class="sequencewidget"
-  i18n:domain="zope">
-  <div tal:repeat="widget view/widgets"
-       tal:omit-tag="">
-    <tr tal:condition="repeat/widget/start">
-      <th></th>
-      <th>
-	<span tal:replace="python: widget[0].label">Key Label</span>
-      </th>
-      <th>
-	<span tal:replace="python: widget[1].label">Value Label</span>
-      </th>
-    </tr>
-    <tr>
-      <td>
-	<input class="editcheck" type="checkbox"
-	       tal:attributes="
-	          name string:${view/name}.remove_${repeat/widget/index}"
-	       tal:condition="view/need_delete" />
-      </td>
-      <td>
-	<span tal:define="error python: widget[0].error"
-	      tal:replace="structure error" tal:condition="error" />
-	<input tal:replace="structure python: widget[0]()" />
-      </td>
-      <td>
-	<span tal:define="error python: widget[1].error"
-	      tal:replace="structure error" tal:condition="error" />
-	<input tal:replace="structure python: widget[1]()" />
-      </td>
-    </tr>
-  </div>
-  <tr>
-    <td colspan="3">
-      <input type="submit" value="Remove selected items"
-             tal:condition="view/need_delete"
-             tal:attributes="name string:${view/name}.remove"
-             i18n:attributes="value remove-selected-items" />
-      <input type="submit" value="Add foo"
-             tal:condition="view/need_add"
-             tal:attributes="name string:${view/name}.add;
-                             value view/addButtonLabel" />
-    </td>
-  </tr>
-</table>
-<input tal:replace="structure view/marker" />
Index: in/waeup.sirp/branches/ulif-fasttables/src/waeup/sirp/jambtables/dictwidget.py
===================================================================
--- /main/waeup.sirp/branches/ulif-fasttables/src/waeup/sirp/jambtables/dictwidget.py	(revision 5296)
+++ 	(revision )
@@ -1,314 +1,0 @@
-##
-## dictwidget.py
-## Login : <uli@pu.smp.net>
-## Started on  Sun Jul 18 03:05:27 2010 Uli Fouquet
-## $Id$
-## 
-## Copyright (C) 2010 Uli Fouquet
-## This program is free software; you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation; either version 2 of the License, or
-## (at your option) any later version.
-## 
-## This program is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-## GNU General Public License for more details.
-## 
-## You should have received a copy of the GNU General Public License
-## along with this program; if not, write to the Free Software
-## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-##
-import grok
-from zope.browserpage import ViewPageTemplateFile
-from zope.component import getMultiAdapter
-from zope.formlib.i18n import _
-from zope.formlib.interfaces import (
-    ISimpleInputWidget, IInputWidget, IDisplayWidget)
-from zope.formlib.sequencewidget import SequenceWidget
-from zope.formlib.widget import DisplayWidget, renderElement
-from zope.i18n import translate
-from zope.publisher.interfaces.browser import IBrowserRequest
-from zope.schema.interfaces import IDict, IField
-
-class DictWidget(SequenceWidget):
-    _type = dict
-    #grok.adapts(IDict, IField, IBrowserRequest)
-    #grok.adapts(IDict, IBrowserRequest)
-    #grok.provides(ISimpleInputWidget)
-    template = ViewPageTemplateFile('dictwidget.pt')
-
-    
-    def __init__(self, context, request, subwidget=None):
-        super(DictWidget, self).__init__(context, None, request)
-        self.subwidget = subwidget
-
-        # The subwidgets are cached in this dict if preserve_widgets is True.
-        self._widgets = {}
-        self.preserve_widgets = False
-
-    def _getWidget(self, i):
-        """Return a widget for the i-th number of the sequence.
-
-        Normally this method creates a new widget each time, but when
-        the ``preserve_widgets`` attribute is True, it starts caching
-        widgets.  We need it so that the errors on the subwidgets
-        would appear only if ``getInputValue`` was called.
-
-        ``getInputValue`` on the subwidgets gets called on each
-        request that has data.
-        """
-        if i not in self._widgets:
-            key_field = self.context.key_type
-            if self.subwidget is not None:
-                key_widget = self.subwidget(key_field, self.request)
-            else:
-                key_widget = getMultiAdapter(
-                    (key_field, self.request), IInputWidget)
-            #key_widget.setPrefix('%s.key.%d.' % (self.name, i))
-            key_widget.setPrefix('%s.key.%d.' % (self.name, i))
-            
-            value_field = self.context.value_type
-            if self.subwidget is not None:
-                value_widget = self.subwidget(value_field, self.request)
-            else:
-                value_widget = getMultiAdapter(
-                    (value_field, self.request), IInputWidget)
-            #value_widget.setPrefix('%s.value.%d.' % (self.name, i))
-            value_widget.setPrefix('%s.value.%d.' % (self.name, i))
-            #import pdb; pdb.set_trace()
-            if not self.preserve_widgets:
-                #return super(DictWidget, self)._getWidget(i)
-                return (key_widget, value_widget)
-            self._widgets[i] = (key_widget, value_widget)
-        #return super(DictWidget, self)._getWidget(i)
-        return self._widgets[i]
-            
-        if i not in self._widgets:
-            field = self.context.value_type
-            if self.subwidget is not None:
-                widget = self.subwidget(field, self.request)
-            else:
-                widget = getMultiAdapter(
-                    (field, self.request), IInputWidget)
-            widget.setPrefix('%s.%d.' % (self.name, i))
-            if not self.preserve_widgets:
-                return widget
-            self._widgets[i] = widget
-        return self._widgets[i]
-
-    def widgets(self):
-        """Return a list of widgets to display"""
-        sequence = self._getRenderedValue()
-        result = []
-        for i, value in enumerate(sequence.items()):
-            widget = self._getWidget(i)
-            widget[0].setRenderedValue(value[0])
-            widget[1].setRenderedValue(value[1])
-            result.append(widget)
-        return result
-
-    def _generateSequence(self):
-        """Extract the values of the subwidgets from the request.
-
-        Returns a list of key-value tuples.
-
-        This can only be called if self.hasInput() returns true.
-        """
-        if self.context.value_type is None:
-            # Why would this ever happen?
-            return []
-        if self.context.key_type is None:
-            return []
-        # the marker field tells how many individual items were
-        # included in the input; we check for exactly that many input
-        # widgets
-        try:
-            count = int(self.request.form[self.name + ".count"])
-        except ValueError:
-            # could not convert to int; the input was not generated
-            # from the widget as implemented here
-            raise WidgetInputError(self.context.__name__, self.context.title)
-
-        # pre-populate
-        sequence = [(None, None)] * count
-        #sequence = [None] * count
-        #sequence = dict()
-
-        # now look through the request for interesting values
-        # in reverse so that we can remove items as we go
-        removing = self.name + ".remove" in self.request.form
-        for i in reversed(range(count)):
-            #widget = self._getWidget(i)
-            key_widget, value_widget = self._getWidget(i)
-            key = None
-            value = None
-            if key_widget.hasValidInput():
-                # catch and set sequence widget errors to ``_error`` attribute
-                try:
-                    key = key_widget.getInputValue()
-                    #sequence[i] = widget.getInputValue()
-                except WidgetInputError, error:
-                    self._error = error
-                    raise self._error
-            if value_widget.hasValidInput():
-                # catch and set sequence widget errors to ``_error`` attribute
-                try:
-                    value = value_widget.getInputValue()
-                    #sequence[i] = widget.getInputValue()
-                except WidgetInputError, error:
-                    self._error = error
-                    raise self._error
-            sequence[i] = (key, value)
-            #if widget.hasValidInput():
-            #    # catch and set sequence widget errors to ``_error`` attribute
-            #    try:
-            #        sequence[i] = widget.getInputValue()
-            #    except WidgetInputError, error:
-            #        self._error = error
-            #        raise self._error
-
-            remove_key = "%s.remove_%d" % (self.name, i)
-            if remove_key in self.request.form and removing:
-                del sequence[i]
-
-        # add an entry to the list if the add button has been pressed
-        if self.name + ".add" in self.request.form:
-            # Should this be using self.context.value_type.missing_value
-            # instead of None?
-            sequence.append((None, None))
-
-        return sequence
-
-    
-    def getInputValue(self):
-        """Return converted and validated widget data.
-
-        If there is no user input and the field is required, then a
-        ``MissingInputError`` will be raised.
-
-        If there is no user input and the field is not required, then
-        the field default value will be returned.
-
-        A ``WidgetInputError`` is raised in the case of one or more
-        errors encountered, inputting, converting, or validating the data.
-        """
-        sequence = super(DictWidget, self).getInputValue()
-        return sequence
-        return self._type(sequence)
-
-    def _getRenderedValue(self):
-        """Returns a dict from the request or _data"""
-        if self._renderedValueSet():
-            if self._data is self.context.missing_value:
-                #sequence = []
-                sequence = dict()
-            else:
-                #sequence = list(self._data)
-                sequence = dict(self._data)
-        elif self.hasInput():
-            #sequence = self._generateSequence()
-            sequence = dict(self._generateSequence())
-        elif self.context.default is not None:
-            #sequence = self.context.default
-            sequence = self.context.default
-        else:
-            #sequence = []
-            seuence = dict()
-        # ensure minimum number of items in the form
-        #while len(sequence) < self.context.min_length:
-        #    # Shouldn't this use self.field.value_type.missing_value,
-        #    # instead of None?
-        #    #sequence.append(None)
-        #    pass
-        return sequence
-
-    # TODO: applyChanges isn't reporting "change" correctly (we're
-    # re-generating the sequence with every edit, and need to be smarter)
-    def applyChanges(self, content):
-        field = self.context
-        value = self.getInputValue()
-        change = field.query(content, self) != value
-        if change:
-            print "SET: ", field, content, value
-            field.set(content, value)
-        else:
-            print "NO SET: ", field, content, value
-        return change
-
-    
-# Basic display widget
-
-class DictDisplayWidget(DisplayWidget):
-
-    _missingValueMessage = _("sequence-value-not-provided",
-                             u"(no value available)")
-
-    _emptySequenceMessage = _("sequence-value-is-empty",
-                              u"(no values)")
-
-    tag = "ol"
-    itemTag = "li"
-    cssClass = "sequenceWidget"
-    extra = ""
-
-    def __init__(self, context, request, subwidget=None):
-        # def __init__(self, context, field, request, subwidget=None):
-        super(DictDisplayWidget, self).__init__(context, request)
-        self.subwidget = subwidget
-
-    def __call__(self):
-        # get the data to display:
-        #import pdb; pdb.set_trace()
-        if self._renderedValueSet():
-            data = self._data
-        else:
-            data = self.context.get(self.context.context)
-
-        # deal with special cases:
-        if data == self.context.missing_value:
-            return translate(self._missingValueMessage, self.request)
-        #data = list(data)
-        data = dict(data)
-        if not data:
-            return translate(self._emptySequenceMessage, self.request)
-
-        parts = []
-        # for i, item in enumerate(data):
-        for i, item in enumerate(data.items()):
-            #widget = self._getWidget(i)
-            key_widget, value_widget = self._getWidget(i)
-            key_widget.setRenderedValue(item[0])
-            value_widget.setRenderedValue(item[1])
-            #widget.setRenderedValue(item)
-            #s = widget()
-            s = "%s: %s" % (key_widget(), value_widget())
-            if self.itemTag:
-                s = "<%s>%s</%s>" % (self.itemTag, s, self.itemTag)
-            parts.append(s)
-        contents = "\n".join(parts)
-        if self.tag:
-            contents = "\n%s\n" % contents
-            contents = renderElement(self.tag,
-                                     cssClass=self.cssClass,
-                                     extra=self.extra,
-                                     contents=contents)
-        return contents
-
-    def _getWidget(self, i):
-        """Get a tuple of key-value widgets for the i-th 'row' of dict.
-        """
-        key_field = self.context.key_type
-        value_field = self.context.value_type
-        if self.subwidget is not None:
-            key_widget = self.subwidget(key_field, self.request)
-            value_widget = self.subwidget(value_field, self.request)
-        else:
-            key_widget = getMultiAdapter(
-                (key_field, self.request), IDisplayWidget)
-            value_widget = getMultiAdapter(
-                (value_field, self.request), IDisplayWidget)
-        key_widget.setPrefix('%s.key.%d.' % (self.name, i))
-        value_widget.setPrefix('%s.value.%d.' % (self.name, i))
-        return (key_widget, value_widget)
-
Index: in/waeup.sirp/branches/ulif-fasttables/src/waeup/sirp/jambtables/tests/test_dictwidget.py
===================================================================
--- /main/waeup.sirp/branches/ulif-fasttables/src/waeup/sirp/jambtables/tests/test_dictwidget.py	(revision 5296)
+++ 	(revision )
@@ -1,509 +1,0 @@
-##
-## test_dictwidget.py
-## Login : <uli@pu.smp.net>
-## Started on  Sun Jul 18 15:47:58 2010 Uli Fouquet
-## $Id$
-## 
-## Copyright (C) 2010 Uli Fouquet
-## This program is free software; you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation; either version 2 of the License, or
-## (at your option) any later version.
-## 
-## This program is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-## GNU General Public License for more details.
-## 
-## You should have received a copy of the GNU General Public License
-## along with this program; if not, write to the Free Software
-## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-##
-"""Dict Field Widget tests.
-"""
-import unittest
-from zope.interface import Interface, implements
-from zope.schema import Tuple, List, TextLine, Dict
-from zope.schema.interfaces import ITextLine
-from zope.component import provideAdapter
-from zope.publisher.browser import TestRequest
-from zope.publisher.interfaces.browser import IDefaultBrowserLayer
-import doctest
-
-from zope.formlib.widgets import TextWidget, ObjectWidget, DisplayWidget
-from zope.formlib.widgets import TupleSequenceWidget, ListSequenceWidget
-from zope.formlib.widgets import SequenceDisplayWidget
-from zope.formlib.widgets import SequenceWidget
-from zope.formlib.interfaces import IDisplayWidget
-from zope.formlib.interfaces import IInputWidget, MissingInputError
-from zope.formlib.interfaces import IWidgetInputError, WidgetInputError
-from zope.formlib.interfaces import IWidgetInputErrorView
-from zope.formlib.widget import CustomWidgetFactory
-from zope.formlib.exception import WidgetInputErrorView
-
-from zope.formlib.tests.support import VerifyResults
-from zope.formlib.tests.test_browserwidget import BrowserWidgetTest
-
-from zope.traversing.testing import setUp as traversingSetUp
-from zope.testing.cleanup import tearDown as traversingTearDown
-
-from waeup.sirp.jambtables.dictwidget import DictWidget, DictDisplayWidget
-
-class DictWidgetTestHelper(object):
-
-    def setUpContent(self, desc=u'', title=u'Foo Title'):
-        class ITestContent(Interface):
-            foo = self._FieldFactory(
-                    title=title,
-                    description=desc,
-                    )
-        class TestObject(object):
-            implements(ITestContent)
-
-        self.content = TestObject()
-        self.field = ITestContent['foo'].bind(self.content)
-        self.request = TestRequest(HTTP_ACCEPT_LANGUAGE='pl')
-        self.request.form['field.foo'] = u'Foo Value'
-        self._widget = self._WidgetFactory(
-            self.field, self.request)
-
-    def setUp(self):
-        traversingSetUp()
-        self.setUpContent()
-
-    def tearDown(self):
-        traversingTearDown()
-        
-    def _FieldFactory(self, **kw):
-        kw.update({
-            '__name__': u'foo', 
-            'key_type': TextLine(__name__=u'bar',title=u'bar'),
-            'value_type': TextLine(__name__=u'baz',title=u'baz')})
-        return Dict(**kw)
-
-
-class DictWidgetTest(DictWidgetTestHelper, BrowserWidgetTest):
-    """Documents and tests the dict widget.
-
-        >>> from zope.interface.verify import verifyClass
-        >>> verifyClass(IInputWidget, DictWidget)
-        True
-    """
-
-    _WidgetFactory = DictWidget
-
-    def testRender(self):
-        pass
-
-    def setUp(self):
-        super(DictWidgetTest, self).setUp()
-        provideAdapter(TextWidget,
-                       (ITextLine, IDefaultBrowserLayer),
-                       IInputWidget, '')
-        provideAdapter(WidgetInputErrorView,
-                       (IWidgetInputError, IDefaultBrowserLayer),
-                       IWidgetInputErrorView, '')
-
-    def test_haveNoData(self):
-        self.failIf(self._widget.hasInput())
-
-    def test_hasInput(self):
-        self._widget.request.form['field.foo.count'] = u'0'
-        self.failUnless(self._widget.hasInput())
-
-    def test_customWidgetFactory(self):
-        """Verify that the widget can be constructed via the CustomWidgetFactory
-        (Issue #293)
-        """
-        key_type = TextLine(__name__=u'bar')
-        value_type = TextLine(__name__=u'baz')
-        self.field = Dict( __name__=u'foo',
-                           value_type=value_type,
-                           key_type=key_type)
-        request = TestRequest()
-
-        # set up the custom widget factory and verify that it works
-        sw = CustomWidgetFactory(DictWidget)
-        widget = sw(self.field, request)
-        assert widget.subwidget is None
-        assert widget.context.value_type is value_type
-
-        # set up a variant that specifies the subwidget to use and verify it
-        class PollOption(object) : pass
-        ow = CustomWidgetFactory(ObjectWidget, PollOption)
-        sw = CustomWidgetFactory(DictWidget, subwidget=ow)
-        widget = sw(self.field, request)
-        assert widget.subwidget is ow
-        assert widget.context.value_type is value_type
-        assert widget.context.key_type is key_type
-
-    def test_subwidget(self):
-        """This test verifies that the specified subwidget is not ignored.
-        (Issue #293)
-        """
-        self.field = Dict(__name__=u'foo',
-                          key_type=TextLine(__name__=u'bar'),
-                          value_type=TextLine(__name__=u'baz'),
-                          )
-        request = TestRequest()
-
-        class PollOption(object) : pass
-        ow = CustomWidgetFactory(ObjectWidget, PollOption)
-        widget = DictWidget(
-            self.field, request, subwidget=ow)
-        assert widget.subwidget is ow
-
-    def test_dict(self):
-        self.field = Dict(
-            __name__=u'foo',
-            key_type=TextLine(__name__=u'bar'),
-            value_type=TextLine(__name__=u'baz'),
-            )
-        request = TestRequest()
-        widget = DictWidget(
-            self.field, request)
-        self.failIf(widget.hasInput())
-        self.assertRaises(MissingInputError, widget.getInputValue)
-
-        request = TestRequest(form={'field.foo.add': u'Add bar',
-                                    'field.foo.count': u'0'})
-        widget = DictWidget(
-            self.field, request)
-        self.assert_(widget.hasInput())
-        self.assertRaises(WidgetInputError, widget.getInputValue)
-
-        request = TestRequest(form={'field.foo.key.0.bar': u'Hello',
-                                    'field.foo.value.0.baz': u'world!',
-                                    'field.foo.count': u'1'})
-        widget = DictWidget(
-            self.field, request)
-        self.assert_(widget.hasInput())
-        self.assertEquals(widget.getInputValue(), {u'Hello': u'world!'})
-
-    def test_new(self):
-        request = TestRequest()
-        widget = TupleSequenceWidget(
-            self.field, self.field.value_type, request)
-        self.failIf(widget.hasInput())
-        self.assertRaises(MissingInputError, widget.getInputValue)
-        check_list = ('input', 'name="field.foo.add"')
-        self.verifyResult(widget(), check_list)
-
-    def test_add(self):
-        request = TestRequest(form={'field.foo.add': u'Add bar',
-                                    'field.foo.count': u'0'})
-        widget = DictWidget(
-            self.field, request)
-        self.assert_(widget.hasInput())
-        self.assertRaises(WidgetInputError, widget.getInputValue)
-        check_list = (
-            'checkbox', 'field.foo.remove_0', 'input', 'field.foo.key.0.bar',
-            'submit', 'submit', 'field.foo.add'
-        )
-        self.verifyResult(widget(), check_list, inorder=True)
-
-    def test_request(self):
-        request = TestRequest(form={'field.foo.key.0.bar': u'Hello',
-                                    'field.foo.value.0.baz': u'world!',
-                                    'field.foo.count': u'1'})
-        #widget = DictWidget(
-        #    self.field, self.field.value_type, request)
-        widget = DictWidget(
-            self.field, request)
-        self.assert_(widget.hasInput())
-        self.assertEquals(widget.getInputValue(), {u'Hello': 'world!'})
-
-    def test_existing(self):
-        request = TestRequest()
-        widget = DictWidget(
-            self.field, request)
-        widget.setRenderedValue({'existing':'value'})
-        self.failIf(widget.hasInput())
-        self.assertRaises(MissingInputError, widget.getInputValue)
-        check_list = (
-            'checkbox', 'field.foo.remove_0', 'input', 'field.foo.key.0.bar',
-                'existing',
-            'submit', 'submit', 'field.foo.add',
-            'field.foo.count" value="1"',
-        )
-        self.verifyResult(widget(), check_list, inorder=True)
-        widget.setRenderedValue({u'existing':u'entry',
-                                 u'second':u'value'})
-        self.failIf(widget.hasInput())
-        self.assertRaises(MissingInputError, widget.getInputValue)
-        check_list = (
-            'checkbox', 'field.foo.remove_0', 'input', 'field.foo.key.0.bar',
-                'second',
-            'checkbox', 'field.foo.remove_1', 'input', 'field.foo.key.1.bar',
-                'existing',
-            'submit', 'submit', 'field.foo.add',
-            'field.foo.count" value="2"',
-        )
-        self.verifyResult(widget(), check_list, inorder=True)
-
-    def test_remove(self):
-        request = TestRequest(form={
-            'field.foo.remove_0': u'1',
-            'field.foo.0.bar': u'existing',
-            'field.foo.1.bar': u'second',
-            'field.foo.remove': u'Remove selected items',
-            'field.foo.count': u'2'})
-        request = TestRequest(form={
-            'field.foo.remove_0': u'1',
-            'field.foo.key.0.bar': u'first',
-            'field.foo.value.0.baz': u'entry',
-            'field.foo.key.1.bar': u'second',
-            'field.foo.value.1.baz': u'entry',
-            'field.foo.remove': u'Remove selected items',
-            'field.foo.count': u'2'})
-        #widget = TupleSequenceWidget(
-        #    self.field, self.field.value_type, request)
-        widget = DictWidget(
-            self.field, request)
-        #widget.setRenderedValue(((u'existing', u'one'), (u'second', u'entry')))
-        #widget.setRenderedValue({u'existing': u'one', u'other': u'entry'})
-        widget.setRenderedValue({u'other': u'entry', u'existing': u'one'})
-        #a = widget.getInputValue()
-        #print "AAAAAAAAAAAAAAAA: ", a
-        self.assertEquals(widget.getInputValue(), {u'second': u'entry'})
-        #self.assertEquals(a, {u'second': u'entry'})
-        output = widget()
-        #print "WIDGET_OUTPUT: ", output
-        check_list = (
-            'checkbox', 'field.foo.remove_0',
-            'input', 'field.foo.key.0.bar', 'other',
-            'input', 'field.foo.value.0.baz', 'entry',
-            'checkbox', 'field.foo.remove_1',
-            'input', 'field.foo.key.1.bar', 'existing',
-            'input', 'field.foo.value.1.baz', 'one',
-            'submit', 'submit', 'field.foo.add',
-            'field.foo.count" value="2"',
-        )
-        #self.verifyResult(widget(), check_list, inorder=True)
-        self.verifyResult(output, check_list, inorder=True)
-
-    def test_min(self):
-        request = TestRequest()
-        self.field.min_length = 2
-        #widget = TupleSequenceWidget(
-        #    self.field, self.field.value_type, request)
-        widget = DictWidget(
-            self.field, request)
-        widget.setRenderedValue({u'existing': u'value', None:None})
-        self.assertRaises(MissingInputError, widget.getInputValue)
-        check_list = (
-            'input', 'field.foo.key.0.bar', 'value=""',
-            'input', 'field.foo.key.1.bar', 'existing',
-            'submit', 'field.foo.add'
-        )
-        s = widget()
-        #print "S: "
-        #print s
-        self.verifyResult(s, check_list, inorder=True)
-        self.assertEquals(s.find('checkbox'), -1)
-
-    def test_max(self):
-        request = TestRequest()
-        self.field.max_length = 1
-        widget = DictWidget(
-            self.field, request)
-        widget.setRenderedValue({u'existing':u'value'})
-        self.assertRaises(MissingInputError, widget.getInputValue)
-        s = widget()
-        self.assertEquals(s.find('field.foo.add'), -1)
-
-    def test_anonymousfield(self):
-        self.field = Dict(__name__=u'foo',
-                          value_type=TextLine(),
-                          key_type=TextLine())
-        request = TestRequest()
-        widget = DictWidget(
-            self.field, request)
-        widget.setRenderedValue({u'existing':u'value'})
-        s = widget()
-        check_list = (
-            'input', '"field.foo.key.0."', 'existing',
-            'submit', 'submit', 'field.foo.add'
-        )
-        s = widget()
-        self.verifyResult(s, check_list, inorder=True)
-
-    def test_usererror(self):
-        self.field = Dict(__name__=u'foo',
-                          key_type=TextLine(__name__='bar'),
-                          value_type=TextLine(__name__='baz'),
-                          )
-        request = TestRequest(form={
-            'field.foo.key.0.bar': u'',
-            'field.foo.value.0.baz': u'value',
-            'field.foo.key.1.bar': u'nonempty',
-            'field.foo.value.1.baz': u'entry',
-            'field.foo.count': u'2'})
-        widget = DictWidget(
-            self.field, request)
-        # Rendering a widget should not raise errors!
-        widget()
-
-        data = widget._generateSequence()
-        self.assertEquals(data, [(None, u'value'),
-                                 (u'nonempty', u'entry')])
-
-    def doctest_widgeterrors(self):
-        """Test that errors on subwidgets appear
-
-            >>> #field = Tuple(__name__=u'foo',
-            >>> #              value_type=TextLine(__name__='bar'))
-            >>> field = Dict(__name__=u'foo',
-            ...              key_type=TextLine(__name__='bar',title=u'bar'),
-            ...              value_type=TextLine(__name__='baz',title=u'baz'))
-            >>> request = TestRequest(form={
-            ...     'field.foo.key.0.bar': u'',
-            ...     'field.foo.value.0.baz': u'some',
-            ...     'field.foo.key.1.bar': u'nonempty',
-            ...     'field.foo.value.1.baz': u'entry',
-            ...     'field.foo.count': u'2'})
-            >>> #widget = TupleSequenceWidget(field, field.value_type, request)
-            >>> widget = DictWidget(field, request)
-
-         If we render the widget, we see no errors:
-
-            >>> print widget()
-            <BLANKLINE>
-            ...
-            <tr>
-              <td>
-                 <input class="editcheck" type="checkbox"
-                        name="field.foo.remove_0" />
-              </td>
-              <td>
-                 <input class="textType" id="field.foo.key.0.bar"
-                        name="field.foo.key.0.bar"
-                        size="20" type="text" value=""  />
-              </td>
-              ...
-            </tr>
-            ...
-
-         However, if we call getInputValue or hasValidInput, the
-         errors on the widgets are preserved and displayed:
-
-            >>> widget.hasValidInput()
-            False
-
-            >>> print widget()
-            <BLANKLINE>
-            ...
-            <tr>
-              <td>
-                 <input class="editcheck" type="checkbox"
-                        name="field.foo.remove_0" />
-              </td>
-              <td>
-                 <span class="error">Required input is missing.</span>
-                 <input class="textType" id="field.foo.key.0.bar"
-                        name="field.foo.key.0.bar"
-                        size="20" type="text" value=""  />
-              </td>
-              ...
-            </tr>
-            ...
-        """
-
-
-
-class SequenceDisplayWidgetTest(
-    VerifyResults, DictWidgetTestHelper, unittest.TestCase):
-
-    def _WidgetFactory(self, *args, **kw):
-        #w = SequenceDisplayWidget(*args, **kw)
-        w = DictDisplayWidget(*args, **kw)
-        w.cssClass = "testwidget"
-        return w
-
-    def setUp(self):
-        self.setUpContent()
-        self.request = TestRequest()
-        #self.widget = self._WidgetFactory(
-        #    self.field, self.field.value_type, self.request)
-        self.widget = self._WidgetFactory(
-            self.field, self.request)
-        provideAdapter(DisplayWidget, (ITextLine, IDefaultBrowserLayer),
-                       IDisplayWidget)
-        
-    def test_render_empty(self):
-        self.content.foo = ()
-        self.assertEquals(self.widget(), '(no values)')
-
-    def test_render_missing(self):
-        self.content.foo = self.field.missing_value
-        self.assertEquals(self.widget(), '(no value available)')
-
-    def test_render_single(self):
-        self.content.foo = {u'one':u'value'}
-        check_list = ['<ol', 'class=', 'testwidget',
-                      '<li', 'one: value', '</li', '</ol']
-        self.verifyResult(self.widget(), check_list, inorder=True)
-
-    def test_render_multiple(self):
-        self.content.foo = {u'one': u'entry',
-                            u'entry': u'two',
-                            u'three': u'a value',
-                            u'fourth': u'entry'}
-        check_list = ['<ol', 'class=', 'testwidget',
-                      '<li', 'entry: two', '</li',
-                      '<li', 'three: a value', '</li',
-                      '<li', 'fourth: entry', '</li',
-                      '<li', 'one: entry', '</li',
-                      '</ol']
-        self.verifyResult(self.widget(), check_list, inorder=True)
-
-    def test_render_alternate_cssClass(self):
-        #self.content.foo = (u'one value',)
-        self.content.foo = {u'one': u'value'}
-        check_list = ['<ol', 'class=', 'altclass',
-                      '<li', 'one: value', '</li', '</ol']
-        self.widget.cssClass = 'altclass'
-        self.verifyResult(self.widget(), check_list, inorder=True)
-
-    def test_honors_subwidget(self):
-        self.widget = self._WidgetFactory(
-            self.field, self.request,
-            subwidget=UppercaseDisplayWidget)
-        self.content.foo = {u'first value': u'second value'}
-        check_list = ['<ol', 'class=', 'testwidget',
-                      '<li', 'FIRST VALUE: SECOND VALUE', '</li',
-                      '</ol']
-        self.verifyResult(self.widget(), check_list, inorder=True)
-
-
-class UppercaseDisplayWidget(DisplayWidget):
-
-    def __call__(self):
-        return super(UppercaseDisplayWidget, self).__call__().upper()
-
-
-def setUp(test):
-    traversingSetUp()
-    provideAdapter(TextWidget,
-                   (ITextLine, IDefaultBrowserLayer),
-                   IInputWidget)
-    provideAdapter(WidgetInputErrorView,
-                   (IWidgetInputError, IDefaultBrowserLayer),
-                   IWidgetInputErrorView)
-
-def tearDown(test):
-    traversingTearDown()
-
-
-def test_suite():
-    return unittest.TestSuite((
-        unittest.makeSuite(DictWidgetTest),
-        doctest.DocTestSuite(setUp=setUp, tearDown=tearDown,
-                             optionflags=doctest.ELLIPSIS
-                             |doctest.NORMALIZE_WHITESPACE
-                             |doctest.REPORT_NDIFF),
-        unittest.makeSuite(SequenceDisplayWidgetTest),
-        ))
-
-if __name__=='__main__':
-    unittest.main(defaultTest='test_suite')
