cubicweb: comparison web/widgets.py

equal deleted inserted replaced

-:3f91ef2397d0
+:3a3263df6cdd
 need_multipart = False
 # generate the "id" attribute with the same value as the "name" (html) attribute
 autoid = True
 html_attributes = set(('id', 'class', 'tabindex', 'accesskey', 'onchange', 'onkeypress'))
 cubicwebns_attributes = set()
 def __init__(self, vreg, subjschema, rschema, objschema,
 role='subject', description=None,
 **kwattrs):
 self.vreg = vreg
 self.rschema = rschema
 def copy(self):
 """shallow copy (useful when you need to modify self.attrs
 because widget instances are cached)
 """
 # brute force copy (subclasses don't have the
 # same __init__ prototype)
 widget = self.__new__(self.__class__)
 widget.__dict__ = dict(self.__dict__)
 widget.attrs = dict(widget.attrs)
 return widget
 @staticmethod
 def size_constraint_attrs(attrs, maxsize):
 """set html attributes in the attrs dict to consider maxsize"""
 pass
 if name in self.cubicwebns_attributes:
 attrs.append(u'cubicweb:%s="%s"' % (name, value))
 elif name in self.html_attributes:
 attrs.append(u'%s="%s"' % (name, value))
 return u' '.join(sorted(attrs))
 def required(self, entity):
 """indicates if the widget needs a value to be filled in"""
 card = self.rschema.cardinality(self.subjtype, self.objtype, self.role)
 return card in '1+'
 def input_id(self, entity):
 try:
 return self.rname
 except AttributeError:
 return eid_param(self.name, entity.eid)
 def render_label(self, entity, label=None):
 """render widget's label"""
 label = label or self.rschema.display_name(entity.req, self.role)
 forid = self.input_id(entity)
 if forid:
 if self.required(entity):
 label = u'<label class="required"%s>%s</label>' % (forattr, label)
 else:
 label = u'<label%s>%s</label>' % (forattr, label)
 return label
 def render_error(self, entity):
 """return validation error for widget's field of the given entity, if
 any
 """
 errex = entity.req.data.get('formerrors')
 example = self.render_example(req)
 if example:
 help.append(u'<span class="helper">(%s: %s)</span>'
 % (req._('sample format'), example))
 return u'&nbsp;'.join(help)
 def render_example(self, req):
 return u''
 def render(self, entity):
 """render the widget for a simple view"""
 if not entity.has_eid():
 return u''
 return entity.printable_value(self.name)
 def edit_render(self, entity, tabindex=None,
 includehelp=False, useid=None, **kwargs):
 """render the widget for edition"""
 # this is necessary to handle multiple edition
 self.rname = eid_param(self.name, entity.eid)
 self.attrs['tabindex'] = entity.req.next_tabindex()
 output = self._edit_render(entity, **kwargs)
 if includehelp:
 output += self.render_help(entity)
 return output
 def _edit_render(self, entity):
 """do the actual job to render the widget for edition"""
 raise NotImplementedError
 def current_values(self, entity):
 if self.rschema.is_final():
 return entity.attribute_values(self.name)
 elif entity.has_eid():
 return [row[0] for row in entity.related(self.name, self.role)]
 return ()
 def current_value(self, entity):
 return _value_from_values(self.current_values(entity))
 def current_display_values(self, entity):
 """same as .current_values but consider values stored in session in case
 if cdvalues is None:
 return self.current_values(entity)
 if not isinstance(cdvalues, (list, tuple)):
 cdvalues = (cdvalues,)
 return cdvalues
 def current_display_value(self, entity):
 """same as .current_value but consider values stored in session in case
 of validation error
 """
 return _value_from_values(self.current_display_values(entity))
 def hidden_input(self, entity, qvalue):
 """return an hidden field which
 1. indicates that a field is edited
 2. hold the old value to easily detect if the field has been modified
 input_type = 'hidden'
 autoid = False
 def __init__(self, vreg, subjschema, rschema, objschema,
 role='subject', **kwattrs):
 InputWidget.__init__(self, vreg, subjschema, rschema, objschema,
 role='subject',
 **kwattrs)
 # disable access key
 del self.attrs['accesskey']
 def current_value(self, entity):
 return value or INTERNAL_FIELD_VALUE
 def current_display_value(self, entity):
 value = InputWidget.current_display_value(self, entity)
 return value or INTERNAL_FIELD_VALUE
 def render_label(self, entity, label=None):
 """render widget's label"""
 return u''
 def render_help(self, entity):
 return u''
 def hidden_input(self, entity, value):
 """no hidden input for hidden input"""
 return ''
 class EidWidget(HiddenWidget):
 def _edit_render(self, entity):
 return u'<input type="hidden" name="eid" value="%s" />' % entity.eid
 @staticmethod
 def size_constraint_attrs(attrs, maxsize):
 """set html attributes in the attrs dict to consider maxsize"""
 attrs['size'] = min(maxsize, 40)
 attrs['maxlength'] = maxsize
 class AutoCompletionWidget(StringWidget):
 cubicwebns_attributes = (StringWidget.cubicwebns_attributes |
 set(('accesskey', 'size', 'maxlength')))
 attrs = ()
 wdgtype = 'SuggestField'
 def current_value(self, entity):
 value = StringWidget.current_value(self, entity)
 return value or INTERNAL_FIELD_VALUE
 def _get_url(self, entity):
 'required' : cssclass,
 })
 class StaticFileAutoCompletionWidget(AutoCompletionWidget):
 wdgtype = 'StaticFileSuggestField'
 def _get_url(self, entity):
 return entity.req.datadir_url + entity.autocomplete_initfuncs[self.rschema]
 class RestrictedAutoCompletionWidget(AutoCompletionWidget):
 wdgtype = 'RestrictedSuggestField'
 class PasswordWidget(InputWidget):
 input_type = 'password'
 def required(self, entity):
 if InputWidget.required(self, entity) and not entity.has_eid():
 return True
 return False
 def current_values(self, entity):
 # on existant entity, show password field has non empty (we don't have
 # the actual value
 if entity.has_eid():
 return (INTERNAL_FIELD_VALUE,)
 name = eid_param(self.name + '-confirm', entity.eid)
 return u'%s<br/>\n<input type="%s" name="%s" id="%s" tabindex="%s"/>&nbsp;<span class="emphasis">(%s)</span>' % (
 html, self.input_type, name, name, entity.req.next_tabindex(),
 entity.req._('confirm password'))
 class TextWidget(Widget):
 html_attributes = Widget.html_attributes | set(('rows', 'cols'))
 @staticmethod
 def size_constraint_attrs(attrs, maxsize):
 """set html attributes in the attrs dict to consider maxsize"""
 if 256 < maxsize < 513:
 attrs['cols'], attrs['rows'] = 60, 5
 else:
 attrs['cols'], attrs['rows'] = 80, 10
 def render(self, entity):
 if not entity.has_eid():
 return u''
 return entity.printable_value(self.name)
 def _edit_render(self, entity, with_format=True):
 req = entity.req
 editor = self._edit_render_textarea(entity, with_format)
 value = self.current_value(entity)
 if isinstance(value, basestring):
 value = html_escape(value)
 return u'%s%s' % (self.hidden_input(entity, value), editor)
 def _edit_render_textarea(self, entity, with_format):
 self.attrs.setdefault('cols', 80)
 self.attrs.setdefault('rows', 20)
 dvalue = self.current_display_value(entity)
 if isinstance(dvalue, basestring):
 self.attrs['tabindex'] = entity.req.next_tabindex()
 else:
 fmtwdgstr = ''
 return u'%s<br/><textarea onkeypress="autogrow(this)" name="%s" %s>%s</textarea>' % (
 fmtwdgstr, self.rname, self.format_attrs(), dvalue)
 class CheckBoxWidget(Widget):
 html_attributes = Widget.html_attributes | set(('checked', ))
 def _edit_render(self, entity):
 value = self.current_value(entity)
 dvalue = self.current_display_value(entity)
 wdgs = [self.hidden_input(entity, value),
 u'<input type="radio" name="%s" value="1" %s/>%s<br/>' % (self.rname, attrs1, entity.req._('yes')),
 u'<input type="radio" name="%s" value="" %s/>%s<br/>' % (self.rname, attrs2, entity.req._('no'))]
 return '\n'.join(wdgs)
 class FileWidget(Widget):
 need_multipart = True
 def _file_wdg(self, entity):
 wdgs = [u'<input type="file" name="%s" %s/>' % (self.rname, self.format_attrs())]
 req = entity.req
 wdgs.append(req._('detach attached file %s' % entity.dc_title()))
 else:
 wdgs.append(u'<br/>')
 wdgs.append(req._('currently attached file: %s' % entity.dc_title()))
 return '\n'.join(wdgs)
 def _edit_render(self, entity):
 return self.hidden_input(entity, None) + self._file_wdg(entity)
 class TextFileWidget(FileWidget):
 else:
 msg = entity.req._(
 'You can either submit a new file using the browse button above'
 ', or edit file content online with the widget below.')
 return msg
 def _edit_render(self, entity):
 wdgs = [self._file_wdg(entity)]
 if entity.attr_metadata(self.name, 'format') in ('text/plain', 'text/html', 'text/rest'):
 msg = self._edit_msg(entity)
 wdgs.append(u'<p><b>%s</b></p>' % msg)
 return '\n'.join(wdgs)
 class ComboBoxWidget(Widget):
 html_attributes = Widget.html_attributes | set(('multiple', 'size'))
 def __init__(self, vreg, subjschema, rschema, objschema,
 multiple=False, **kwattrs):
 super(ComboBoxWidget, self).__init__(vreg, subjschema, rschema, objschema,
 **kwattrs)
 if multiple:
 self.attrs['multiple'] = 'multiple'
 if not 'size' in self.attrs:
 self.attrs['size'] = '5'
 # disable access key (dunno why but this is not allowed by xhtml 1.0)
 del self.attrs['accesskey']
 def vocabulary(self, entity):
 raise NotImplementedError()
 def form_value(self, entity, value, values):
 if value in values:
 flag = 'selected="selected"'
 else:
 flag = ''
 value, flag = self.form_value(entity, value, dvalues)
 res.append(u'<option value="%s" %s>%s</option>' % (value, flag, html_escape(label)))
 res.append(u'</select>')
 return '\n'.join(res)
 class StaticComboBoxWidget(ComboBoxWidget):
 def __init__(self, vreg, subjschema, rschema, objschema,
 vocabfunc, multiple=False, sort=False, **kwattrs):
 super(StaticComboBoxWidget, self).__init__(vreg, subjschema, rschema, objschema,
 multiple, **kwattrs)
 self.sort = sort
 if self.sort:
 choices = sorted(choices)
 if self.rschema.rproperty(self.subjtype, self.objtype, 'internationalizable'):
 return zip((entity.req._(v) for v in choices), choices)
 return zip(choices, choices)
 class EntityLinkComboBoxWidget(ComboBoxWidget):
 """to be used be specific forms"""
 def current_values(self, entity):
 if entity.has_eid():
 return [r[0] for r in entity.related(self.name, self.role)]
 defaultmeth = 'default_%s_%s' % (self.role, self.name)
 if hasattr(entity, defaultmeth):
 return getattr(entity, defaultmeth)()
 return ()
 def vocabulary(self, entity):
 return [('', INTERNAL_FIELD_VALUE)] + entity.vocabulary(self.rschema, self.role)
 class RawDynamicComboBoxWidget(EntityLinkComboBoxWidget):
 def vocabulary(self, entity, limit=None):
 req = entity.req
 # first see if its specified by __linkto form parameters
 linkedto = entity.linked_to(self.name, self.role)
 if linkedto:
 relatedvocab = []
 return res + entity.vocabulary(self.rschema, self.role) + relatedvocab
 class DynamicComboBoxWidget(RawDynamicComboBoxWidget):
 def vocabulary(self, entity, limit=None):
 return sorted(super(DynamicComboBoxWidget, self).vocabulary(entity, limit))
 class AddComboBoxWidget(DynamicComboBoxWidget):
 class IntegerWidget(StringWidget):
 def __init__(self, vreg, subjschema, rschema, objschema, **kwattrs):
 kwattrs['size'] = 5
 kwattrs['maxlength'] = 15
 StringWidget.__init__(self, vreg, subjschema, rschema, objschema, **kwattrs)
 def render_example(self, req):
 return '23'
 class FloatWidget(StringWidget):
 def __init__(self, vreg, subjschema, rschema, objschema, **kwattrs):
 kwattrs['size'] = 5
 kwattrs['maxlength'] = 15
 StringWidget.__init__(self, vreg, subjschema, rschema, objschema, **kwattrs)
 def render_example(self, req):
 formatstr = req.property_value('ui.float-format')
 return formatstr % 1.23
 def current_values(self, entity):
 values = entity.attribute_values(self.name)
 if values:
 formatstr = entity.req.property_value('ui.float-format')
 value = values[0]
 class DecimalWidget(StringWidget):
 def __init__(self, vreg, subjschema, rschema, objschema, **kwattrs):
 kwattrs['size'] = 5
 kwattrs['maxlength'] = 15
 StringWidget.__init__(self, vreg, subjschema, rschema, objschema, **kwattrs)
 def render_example(self, req):
 return '345.0300'
 class DateWidget(StringWidget):
 _ = req._
 monthnames = [_(mname) for mname in cls.monthnames]
 daynames = [_(dname) for dname in cls.daynames]
 req.html_headers.define_var('MONTHNAMES', monthnames)
 req.html_headers.define_var('DAYNAMES', daynames)
 def __init__(self, vreg, subjschema, rschema, objschema, **kwattrs):
 kwattrs.setdefault('size', 10)
 kwattrs.setdefault('maxlength', 10)
 StringWidget.__init__(self, vreg, subjschema, rschema, objschema, **kwattrs)
 def __init__(self, vreg, subjschema, rschema, objschema, **kwattrs):
 kwattrs['size'] = 16
 kwattrs['maxlength'] = 16
 DateWidget.__init__(self, vreg, subjschema, rschema, objschema, **kwattrs)
 def render_example(self, req):
 formatstr1 = req.property_value('ui.datetime-format')
 formatstr2 = req.property_value('ui.date-format')
 return req._('%(fmt1)s, or without time: %(fmt2)s') % {
 'fmt1': datetime.now().strftime(formatstr1),
 def __init__(self, vreg, subjschema, rschema, objschema, **kwattrs):
 kwattrs['size'] = 5
 kwattrs['maxlength'] = 5
 StringWidget.__init__(self, vreg, subjschema, rschema, objschema, **kwattrs)
 class EmailWidget(StringWidget):
 def render(self, entity):
 email = getattr(entity, self.name)
 if not email:
 return u''
 return u'<a href="mailto:%s">%s</a>' % (email, email)
 class URLWidget(StringWidget):
 def render(self, entity):
 url = getattr(entity, self.name)
 if not url:
 return u''
 url = html_escape(url)
 return u'<a href="%s">%s</a>' % (url, url)
 class EmbededURLWidget(StringWidget):
 def render(self, entity):
 url = getattr(entity, self.name)
 if not url:
 return u''
 aurl = html_escape(entity.build_url('embed', url=url))
 return u'<a href="%s">%s</a>' % (aurl, url)
 def widget_factory(vreg, subjschema, rschema, objschema, role='subject',
 **kwargs):
 """return the most adapated widget to edit the relation
 'subjschema rschema objschema' according to information found in the schema
 return factory(vreg, subjschema, rschema, objschema, wcls=wcls,
 role=role, **kwargs)
 # factories to find the most adapated widget according to a type and other constraints
 def _string_widget_factory(vreg, subjschema, rschema, objschema, wcls=None, **kwargs):
 w = None
 for c in rschema.rproperty(subjschema, objschema, 'constraints'):
 if isinstance(c, StaticVocabularyConstraint):
 # may have been set by a previous SizeConstraint but doesn't make sense
 # here (even doesn't have the same meaning on a combobox actually)
 kwargs.pop('size', None)
 return (wcls or StaticComboBoxWidget)(vreg, subjschema, rschema, objschema,
 vocabfunc=c.vocabulary, **kwargs)
 if isinstance(c, SizeConstraint) and c.max is not None:
 # don't return here since a StaticVocabularyConstraint may
 # follow
 'Decimal':  DecimalWidget,
 'Password': PasswordWidget,
 'String' :  StringWidget,
 'Time':     TimeWidget,
 }
 # widgets registry
 WIDGETS = {}
 def register(widget_list):
 for obj in widget_list:
 if isinstance(obj, type) and issubclass(obj, Widget):

branch	tls-sprint
changeset 1554	3a3263df6cdd
parent 1360	13ae1121835e
child 1641	2c80b09d8d86