blinkster: comparison web/lib/django/forms/widgets.py

equal deleted inserted replaced

-:b758351d191f
+:cc9b7e14412b
 """
 HTML Widget classes
 """
-try:
+import django.utils.copycompat as copy
-set
-except NameError:
-from sets import Set as set   # Python 2.3 fallback
-import copy
 from itertools import chain
 from django.conf import settings
 from django.utils.datastructures import MultiValueDict, MergeDict
 from django.utils.html import escape, conditional_escape
 from django.utils.translation import ugettext
 from django.utils.encoding import StrAndUnicode, force_unicode
 from django.utils.safestring import mark_safe
-from django.utils import datetime_safe
+from django.utils import formats
-from datetime import time
+import time
+import datetime
 from util import flatatt
 from urlparse import urljoin
 __all__ = (
 'Media', 'MediaDefiningClass', 'Widget', 'TextInput', 'PasswordInput',
 for name in MEDIA_TYPES:
 getattr(self, 'add_' + name)(media_attrs.get(name, None))
 # Any leftover attributes must be invalid.
 # if media_attrs != {}:
-#     raise TypeError, "'class Media' has invalid attribute(s): %s" % ','.join(media_attrs.keys())
+#     raise TypeError("'class Media' has invalid attribute(s): %s" % ','.join(media_attrs.keys()))
 def __unicode__(self):
 return self.render()
 def render(self):
 return Media(**{str(name): getattr(self, '_' + name)})
 raise KeyError('Unknown media type "%s"' % name)
 def add_js(self, data):
 if data:
-self._js.extend([path for path in data if path not in self._js])
+for path in data:
+if path not in self._js:
+self._js.append(path)
 def add_css(self, data):
 if data:
 for medium, paths in data.items():
-self._css.setdefault(medium, []).extend([path for path in paths if path not in self._css[medium]])
+for path in paths:
+if not self._css.get(medium) or path not in self._css[medium]:
+self._css.setdefault(medium, []).append(path)
 def __add__(self, other):
 combined = Media()
 for name in MEDIA_TYPES:
 getattr(combined, 'add_' + name)(getattr(self, '_' + name, None))
 self.choices = choices
 def render(self, name, value, attrs=None, choices=()):
 if value is None: value = []
 final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
-return mark_safe(u'\n'.join([(u'<input%s />' %
+id_ = final_attrs.get('id', None)
-flatatt(dict(value=force_unicode(v), **final_attrs)))
+inputs = []
-for v in value]))
+for i, v in enumerate(value):
+input_attrs = dict(value=force_unicode(v), **final_attrs)
+if id_:
+# An ID attribute was given. Add a numeric index as a suffix
+# so that the inputs don't all have the same ID attribute.
+input_attrs['id'] = '%s_%s' % (id_, i)
+inputs.append(u'<input%s />' % flatatt(input_attrs))
+return mark_safe(u'\n'.join(inputs))
 def value_from_datadict(self, data, files, name):
 if isinstance(data, (MultiValueDict, MergeDict)):
 return data.getlist(name)
 return data.get(name, None)
 return mark_safe(u'<textarea%s>%s</textarea>' % (flatatt(final_attrs),
 conditional_escape(force_unicode(value))))
 class DateInput(Input):
 input_type = 'text'
-format = '%Y-%m-%d'     # '2006-10-25'
+format = None
 def __init__(self, attrs=None, format=None):
 super(DateInput, self).__init__(attrs)
 if format:
 self.format = format
 def _format_value(self, value):
 if value is None:
 return ''
 elif hasattr(value, 'strftime'):
-value = datetime_safe.new_date(value)
+return formats.localize_input(value, self.format)
-return value.strftime(self.format)
 return value
 def render(self, name, value, attrs=None):
 value = self._format_value(value)
 return super(DateInput, self).render(name, value, attrs)
 def _has_changed(self, initial, data):
+# If our field has show_hidden_initial=True, initial will be a string
+# formatted by HiddenInput using formats.localize_input, which is not
+# necessarily the format used for this widget. Attempt to convert it.
+try:
+input_format = formats.get_format('DATE_INPUT_FORMATS')[0]
+initial = datetime.date(*time.strptime(initial, input_format)[:3])
+except (TypeError, ValueError):
+pass
 return super(DateInput, self)._has_changed(self._format_value(initial), data)
 class DateTimeInput(Input):
 input_type = 'text'
-format = '%Y-%m-%d %H:%M:%S'     # '2006-10-25 14:30:59'
+format = None
 def __init__(self, attrs=None, format=None):
 super(DateTimeInput, self).__init__(attrs)
 if format:
 self.format = format
 def _format_value(self, value):
 if value is None:
 return ''
 elif hasattr(value, 'strftime'):
-value = datetime_safe.new_datetime(value)
+return formats.localize_input(value, self.format)
-return value.strftime(self.format)
 return value
 def render(self, name, value, attrs=None):
 value = self._format_value(value)
 return super(DateTimeInput, self).render(name, value, attrs)
 def _has_changed(self, initial, data):
+# If our field has show_hidden_initial=True, initial will be a string
+# formatted by HiddenInput using formats.localize_input, which is not
+# necessarily the format used for this widget. Attempt to convert it.
+try:
+input_format = formats.get_format('DATETIME_INPUT_FORMATS')[0]
+initial = datetime.datetime(*time.strptime(initial, input_format)[:6])
+except (TypeError, ValueError):
+pass
 return super(DateTimeInput, self)._has_changed(self._format_value(initial), data)
 class TimeInput(Input):
 input_type = 'text'
-format = '%H:%M:%S'     # '14:30:59'
+format = None
 def __init__(self, attrs=None, format=None):
 super(TimeInput, self).__init__(attrs)
 if format:
 self.format = format
 def _format_value(self, value):
 if value is None:
 return ''
 elif hasattr(value, 'strftime'):
-return value.strftime(self.format)
+return formats.localize_input(value, self.format)
 return value
 def render(self, name, value, attrs=None):
 value = self._format_value(value)
 return super(TimeInput, self).render(name, value, attrs)
 def _has_changed(self, initial, data):
+# If our field has show_hidden_initial=True, initial will be a string
+# formatted by HiddenInput using formats.localize_input, which is not
+# necessarily the format used for this  widget. Attempt to convert it.
+try:
+input_format = formats.get_format('TIME_INPUT_FORMATS')[0]
+initial = datetime.time(*time.strptime(initial, input_format)[3:6])
+except (TypeError, ValueError):
+pass
 return super(TimeInput, self)._has_changed(self._format_value(initial), data)
 class CheckboxInput(Widget):
 def __init__(self, attrs=None, check_test=bool):
 super(CheckboxInput, self).__init__(attrs)
 def value_from_datadict(self, data, files, name):
 if name not in data:
 # A missing value means False because HTML form submission does not
 # send results for unselected checkboxes.
 return False
-return super(CheckboxInput, self).value_from_datadict(data, files, name)
+value = data.get(name)
+# Translate true and false strings to boolean values.
+values =  {'true': True, 'false': False}
+if isinstance(value, basestring):
+value = values.get(value.lower(), value)
+return value
 def _has_changed(self, initial, data):
 # Sometimes data or initial could be None or u'' which should be the
 # same thing as False.
 return bool(initial) != bool(data)
 final_attrs = self.build_attrs(attrs, name=name)
 output = [u'<select%s>' % flatatt(final_attrs)]
 options = self.render_options(choices, [value])
 if options:
 output.append(options)
-output.append('</select>')
+output.append(u'</select>')
 return mark_safe(u'\n'.join(output))
 def render_options(self, choices, selected_choices):
 def render_option(option_value, option_label):
 option_value = force_unicode(option_value)
 u'3': False,
 'False': False,
 False: False}.get(value, None)
 def _has_changed(self, initial, data):
-# Sometimes data or initial could be None or u'' which should be the
+# For a NullBooleanSelect, None (unknown) and False (No)
-# same thing as False.
+# are not the same
-return bool(initial) != bool(data)
+if initial is not None:
+initial = bool(initial)
+if data is not None:
+data = bool(data)
+return initial != data
 class SelectMultiple(Select):
 def render(self, name, value, attrs=None, choices=()):
 if value is None: value = []
 final_attrs = self.build_attrs(attrs, name=name)
 for w in self.widgets:
 media = media + w.media
 return media
 media = property(_get_media)
+def __deepcopy__(self, memo):
+obj = super(MultiWidget, self).__deepcopy__(memo)
+obj.widgets = copy.deepcopy(self.widgets)
+return obj
 class SplitDateTimeWidget(MultiWidget):
 """
 A Widget that splits datetime input into two <input type="text"> boxes.
 """
 date_format = DateInput.format
 class SplitHiddenDateTimeWidget(SplitDateTimeWidget):
 """
 A Widget that splits datetime input into two <input type="hidden"> inputs.
 """
-def __init__(self, attrs=None):
+is_hidden = True
-widgets = (HiddenInput(attrs=attrs), HiddenInput(attrs=attrs))
-super(SplitDateTimeWidget, self).__init__(widgets, attrs)
+def __init__(self, attrs=None, date_format=None, time_format=None):
+super(SplitHiddenDateTimeWidget, self).__init__(attrs, date_format, time_format)
+for widget in self.widgets:
+widget.input_type = 'hidden'
+widget.is_hidden = True

changeset 29	cc9b7e14412b
parent 0	0d40e90630ef