def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
return float(input)
except ValueError, v:
raise ConversionError(_("Invalid floating point data"), v)
def _toFieldValue(self, input):
if input is None or input == '':
return self.context.missing_value
try:
seek = input.seek
read = input.read
except AttributeError, e:
raise ConversionError(_('Form input is not a file object'), e)
def _toFieldValue(self, value):
value = super(TextAreaWidget, self)._toFieldValue(value)
if value:
try:
value = unicode(value)
except ValueError, v:
raise ConversionError(_("Invalid unicode data"), v)
else:
value = value.replace("\r\n", "\n")
def _toFieldValue(self, input):
"""See SimpleInputWidget"""
if input is None:
input = []
elif not isinstance(input, list):
input = [input]
try:
values = self.convertTokensToValues(input)
except InvalidValue, e:
raise ConversionError(_("Invalid value"), e)
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
formatter = self.request.locale.dates.getFormatter(
self._category, (self.displayStyle or None))
return formatter.parse(input)
except (DateTimeParseError, ValueError), v:
raise ConversionError(_("Invalid datetime data"),
"%s (%r)" % (v, input))
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
# TODO: Currently datetimes return in local (server)
# time zone if no time zone information was given.
# Maybe offset-naive datetimes should be returned in
# this case? (DV)
return parseDatetimetz(input)
except (DateTimeError, ValueError, IndexError), v:
raise ConversionError(_("Invalid datetime data"), v)
def _toFieldValue(self, input):
if self.convert_missing_value and input == self._missing:
value = self.context.missing_value
else:
# We convert everything to unicode. This might seem a bit crude,
# but anything contained in a TextWidget should be representable
# as a string. Note that you always have the choice of overriding
# the method.
try:
value = unicode(input)
except ValueError, v:
raise ConversionError(_("Invalid text data"), v)
def __call__(self):
result = ['<div class="value">']
value = self._value()
field = self.context
if value:
for v in value:
try:
term = self.terms.getTerm(v)
except LookupError:
continue # skip
else:
result.append(
' <input type="checkbox" name="%s.checked:list"'
' value=%s />' %
(self.name, xml.sax.saxutils.quoteattr(term.token)))
result.append(' ' + self.renderTermForDisplay(term))
result.append(
' <input type="hidden" name="%s:list" value=%s />' %
(self.name, xml.sax.saxutils.quoteattr(term.token)))
result.append(' <br />')
result.append(
' <input type="submit" name="%s.remove" value="%s" />' %
(self.name,
self._translate(
_("MultipleSourceInputWidget-remove", default="Remove"))))
result.append(' <br />')
result.append(
' <input type="hidden" name="%s.displayed" value="y" />' %
self.name)
result.append(' <div class="queries">')
for name, queryview in self.queryviews:
result.append(' <div class="query">')
result.append(' <div class="queryinput">')
result.append(queryview.render(name))
result.append(' </div> <!-- queryinput -->')
qresults = queryview.results(name)
if qresults:
result.append(' <div class="queryresults">\n%s' %
self._renderResults(qresults, name))
result.append(' </div> <!-- queryresults -->')
result.append(' </div> <!-- query -->')
result.append(' </div> <!-- queries -->')
result.append('</div> <!-- value -->')
return '\n'.join(result)
def _renderResults(self, results, name):
terms = []
apply = self._translate(
_("SourceListInputWidget-apply", default="Apply"))
for value in results:
term = self.terms.getTerm(value)
terms.append((self._translate(term.title), term.token))
terms.sort()
return ('<select name="%s.selection:list" multiple>\n'
'%s\n'
'</select>\n'
'<input type="submit" name="%s.apply" value="%s" />' %
(name, '\n'.join([('<option value="%s">%s</option>' %
(token, title))
for (title, token) in terms]), name, apply))
class ItemDisplayWidget(SingleDataHelper, ItemsWidgetBase):
"""Simple single-selection display that can be used in many cases."""
def __init__(self, *args, **kw):
ItemsWidgetBase.__init__(self, *args, **kw)
self.required = False
_messageNoValue = _("item-missing-single-value-for-display", "")
def __call__(self):
"""See IBrowserWidget."""
value = self._getFormValue()
if not value:
return self.translate(self._messageNoValue)
else:
term = self.vocabulary.getTerm(value)
return self.textForValue(term)
class RadioWidget(SelectWidget):
"""Radio widget for single item choices.
This widget can be used when the number of selections is going
to be small.
"""
orientation = "vertical"
_messageNoValue = _("vocabulary-missing-single-value-for-edit",
"(no value)")
def renderItem(self, index, text, value, name, cssClass):
"""Render an item of the list."""
return self._renderItem(index, text, value, name, cssClass)
def renderSelectedItem(self, index, text, value, name, cssClass):
"""Render a selected item of the list."""
return self._renderItem(index,
text,
value,
name,
cssClass,
checked=True)
def _renderItem(self, index, text, value, name, cssClass, checked=False):
kw = {}
if checked:
kw['checked'] = 'checked'
id = '%s.%s' % (name, index)
elem = renderElement(u'input',
value=value,
name=name,
id=id,
cssClass=cssClass,
type='radio',
**kw)
return renderElement(u'label',
contents='%s %s' % (elem, text),
**{'for': id})
def renderValue(self, value):
rendered_items = self.renderItems(value)
if self.orientation == 'horizontal':
return " ".join(rendered_items)
else:
return "<br />".join(rendered_items)
class SelectWidget(ItemsEditWidgetBase):
"""Provide a selection list for the item."""
_messageNoValue = _("vocabulary-missing-single-value-for-edit",
"(no value)")
def renderValue(self, value):
rendered_items = self.renderItems(value)
contents = "\n%s\n" % "\n".join(rendered_items)
return renderElement('select',
name=self.name,
id=self.name,
contents=contents,
size=self.size,
extra=self.extra)
def renderItems(self, value):
return self.renderItemsWithValues([value])
def update(self):
if self.update_status is not None:
# We've been called before. Just return the previous result.
return self.update_status
if Update in self.request:
self.update_status = ''
try:
data = getWidgetsData(self, self.schema, names=self.fieldNames)
self.createAndAdd(data)
except WidgetsError, errors:
self.errors = errors
self.update_status = _("An error occurred.")
return self.update_status
self.request.response.redirect(self.nextURL())
def __call__(self):
if self._renderedValueSet():
seq = self._data
else:
seq = self.context.default
terms = getMultiAdapter((self.source, self.request),
zope.browser.interfaces.ITerms)
result = []
for value in seq:
try:
term = terms.getTerm(value)
except LookupError:
value = self._translate(
_("SourceDisplayWidget-invalid", default="Invalid value"))
else:
value = self.renderTermForDisplay(term)
result.append(value)
return '<br />\n'.join(result)
class ItemsMultiDisplayWidget(MultiDataHelper, ItemsWidgetBase):
"""Displays a sequence of items."""
def __init__(self, *args, **kw):
ItemsWidgetBase.__init__(self, *args, **kw)
self.required = False
_messageNoValue = _("vocabulary-missing-multiple-value-for-display", "")
itemTag = 'li'
tag = 'ol'
def __call__(self):
"""See IBrowserWidget."""
value = self._getFormValue()
if value:
rendered_items = self.renderItems(value)
return renderElement(self.tag,
id=self.name,
cssClass=self.cssClass,
contents="\n".join(rendered_items),
extra=self.extra)
else:
return self.translate(self._messageNoValue)
def renderItems(self, value):
"""Render items of sequence."""
items = []
cssClass = self.cssClass or ''
if cssClass:
cssClass += "-item"
tag = self.itemTag
for item in value:
term = self.vocabulary.getTerm(item)
items.append(
renderElement(tag,
cssClass=cssClass,
contents=escape(self.textForValue(term))))
return items
class ItemsMultiEditWidgetBase(MultiDataHelper, ItemsEditWidgetBase):
"""Items widget supporting multiple selections."""
_messageNoValue = _("vocabulary-missing-multiple-value-for-edit",
"(no values)")
_displayItemForMissingValue = False
def renderItems(self, value):
if value == self.context.missing_value:
values = []
else:
values = list(value)
return self.renderItemsWithValues(values)
def renderValue(self, value):
# All we really add here is the ':list' in the name argument
# and mutliple='multiple' to renderElement().
rendered_items = self.renderItems(value)
return renderElement(self.tag,
name=self.name + ':list',
id=self.name,
multiple='multiple',
size=self.size,
contents="\n".join(rendered_items),
extra=self.extra)
def hidden(self):
items = []
for item in self._getFormValue():
items.append(
renderElement(u'input',
type='hidden',
name=self.name + ':list',
id=self.name,
value=self.vocabulary.getTerm(item).token,
cssClass=self.cssClass,
extra=self.extra))
return '\n'.join(items)
class EditFormDirective(EditFormDirectiveBase):
default_template = 'edit.pt'
title = _('Edit')
def _handle_menu(self):
if self.menu:
menuItemDirective(self._context,
self.menu,
self.for_ or self.schema,
'@@' + self.name,
self.title,
permission=self.permission,
layer=self.layer)
def __call__(self):
self._processWidgets()
self._handle_menu()
self._context.action(
discriminator=self._discriminator(),
callable=EditViewFactory,
args=self._args(),
)
def _toFieldValue(self, input):
if input:
try:
return self.convertTokensToValues([input])[0]
except InvalidValue, e:
raise ConversionError(_("Invalid value"), e)
def BooleanRadioWidget(field, request, true=_('on'), false=_('off')):
vocabulary = SimpleVocabulary.fromItems(((true, True), (false, False)))
widget = RadioWidget(field, vocabulary, request)
widget.required = False
return widget
def BooleanSelectWidget(field, request, true=_('on'), false=_('off')):
vocabulary = SimpleVocabulary.fromItems(((true, True), (false, False)))
widget = SelectWidget(field, vocabulary, request)
widget.size = 2
widget.required = False
return widget
def BooleanDropdownWidget(field, request, true=_('on'), false=_('off')):
vocabulary = SimpleVocabulary.fromItems(((true, True), (false, False)))
widget = DropdownWidget(field, vocabulary, request)
widget.required = False
return widget
_msg_true = _("True")
_msg_false = _("False")
class BooleanDisplayWidget(DisplayWidget):
def __call__(self):
if self._renderedValueSet():
value = self._data
else:
value = self.context.default
if value:
return _msg_true
else:
return _msg_false
