cubicweb: comparison web/formrenderers.py

equal deleted inserted replaced

-:6cd6172718bb
+:97774eb6443b
 display_fields = None # None -> all fields
 display_label = True
 display_help = True
 display_progress_div = True
 button_bar_class = u'formButtonBar'
 def __init__(self, **kwargs):
 if self._set_options(kwargs):
 raise ValueError('unconsumed arguments %s' % kwargs)
 def _set_options(self, kwargs):
 try:
 setattr(self, key, kwargs.pop(key))
 except KeyError:
 continue
 return kwargs
 # renderer interface ######################################################
 def render(self, form, values):
 self._set_options(values)
 form.add_media()
 data = []
 w = data.append
 self.render_buttons(w, form)
 w(u'</fieldset>')
 w(u'</form>')
 errormsg = self.error_message(form)
 if errormsg:
 data.insert(0, errormsg)
 return '\n'.join(data)
 def render_label(self, form, field):
 label = form.req._(field.label)
 attrs = {'for': form.context[field]['id']}
 displayed = req.data['displayederrors']
 errors = sorted((field, err) for field, err in errex.errors.items()
 if not field in displayed)
 if errors:
 if len(errors) > 1:
 templstr = '<li>%s</li>\n'
 else:
 templstr = '&nbsp;%s\n'
 for field, err in errors:
 if field is None:
 errormsg += templstr % err
 errormsg += templstr % '%s: %s' % (req._(field), err)
 if len(errors) > 1:
 errormsg = '<ul>%s</ul>' % errormsg
 return u'<div class="errorMessage">%s</div>' % errormsg
 return u''
 def open_form(self, form, values):
 if form.form_needs_multipart:
 enctype = 'multipart/form-data'
 else:
 enctype = 'application/x-www-form-urlencoded'
 if form.cssclass:
 tag += ' class="%s"' % html_escape(form.cssclass)
 if form.cwtarget:
 tag += ' cubicweb:target="%s"' % html_escape(form.cwtarget)
 return tag + '>'
 def display_field(self, form, field):
 return (self.display_fields is None
 or field.name in self.display_fields
 or field.name in form.internal_fields)
 def render_fields(self, w, form, values):
 form.form_build_context(values)
 fields = self._render_hidden_fields(w, form)
 if fields:
 self._render_fields(fields, w, form)
 self.render_child_forms(w, form, values)
 def render_child_forms(self, w, form, values):
 # render
 for childform in getattr(form, 'forms', []):
 self.render_fields(w, childform, values)
 def _render_hidden_fields(self, w, form):
 fields = form.fields[:]
 fields.remove(field)
 elif not field.is_visible():
 w(field.render(form, self))
 fields.remove(field)
 return fields
 def _render_fields(self, fields, w, form):
 w(u'<table class="attributeForm">')
 for field in fields:
 w(u'<tr>')
 if self.display_label:
 +--------------+--------------+---------+
 | field1 label | field2 label |         |
 +--------------+--------------+---------+
 | field1 input | field2 input | buttons
 +--------------+--------------+---------+
 """
 display_help = False
 def _render_fields(self, fields, w, form):
 w(u'<table border="0">')
 w(u'<tr>')
 for field in fields:
 if self.display_label:
 w(u'<th class="labelCol">%s</th>' % self.render_label(form, field))
 if self.display_help:
 w(self.render_help(form, field))
 # empty slot for buttons
 w(u'<th class="labelCol">&nbsp;</th>')
 w(u'</tr>')
 w(u'<tr>')
 for field in fields:
 error = form.form_field_error(field)
 if error:
 w(u'<td class="error" style="width:100%;">')
 w(error)
 else:
 w(u'</tr>')
 w(u'</table>')
 def render_buttons(self, w, form):
 pass
 class EntityCompositeFormRenderer(FormRenderer):
 """specific renderer for multiple entities edition form (muledit)"""
 def render_fields(self, w, form, values):
 if not form.is_subform:
 w(u'<table class="listing">')
 super(EntityCompositeFormRenderer, self).render_fields(w, form, values)
 if not form.is_subform:
 w(u'</table>')
 def _render_fields(self, fields, w, form):
 if form.is_subform:
 entity = form.edited_entity
 values = form._previous_values
 qeid = eid_param('eid', entity.eid)
 onclick="setCheckboxesState('eid', this.checked)"))
 for field in self.forms[0].fields:
 if self.display_field(form, field) and field.is_visible():
 w(u'<th>%s</th>' % form.req._(field.label))
 w(u'</tr>')
 class EntityFormRenderer(FormRenderer):
 """specific renderer for entity edition form (edition)"""
 _options = FormRenderer._options + ('display_relations_form',)
 display_relations_form = True
 def render(self, form, values):
 rendered = super(EntityFormRenderer, self).render(form, values)
 return rendered + u'</div>' # close extra div introducted by open_form
 def open_form(self, form, values):
 attrs_fs_label = ('<div class="iformTitle"><span>%s</span></div>'
 % form.req._('main informations'))
 attrs_fs_label += '<div class="formBody">'
 return attrs_fs_label + super(EntityFormRenderer, self).open_form(form, values)
 def render_fields(self, w, form, values):
 super(EntityFormRenderer, self).render_fields(w, form, values)
 self.inline_entities_form(w, form)
-if form.edited_entity.has_eid() and self.display_relations_table:
+if form.edited_entity.has_eid() and self.display_relations_form:
 self.relations_form(w, form)
 def _render_fields(self, fields, w, form):
 if not form.edited_entity.has_eid() or form.edited_entity.has_perm('update'):
 super(EntityFormRenderer, self)._render_fields(fields, w, form)
 def render_buttons(self, w, form):
 if len(form.form_buttons) == 3:
 w("""<table width="100%%">
 <tbody>
 <tr><td align="center">
 </td></tr>
 </tbody>
 </table>""" % tuple(button.render(form) for button in form.form_buttons))
 else:
 super(EntityFormRenderer, self).render_buttons(w, form)
 def relations_form(self, w, form):
 srels_by_cat = form.srelations_by_category(('generic', 'metadata'), 'add')
 if not srels_by_cat:
 return u''
 req = form.req
 w(u'<ul>')
 for viewparams in related:
 w(u'<li class="invisible">%s<div id="span%s" class="%s">%s</div></li>'
 % (viewparams[1], viewparams[0], viewparams[2], viewparams[3]))
 if not form.force_display and form.maxrelitems < len(related):
 link = (u'<span class="invisible">'
 '[<a href="javascript: window.location.href+=\'&amp;__force_display=1\'">%s</a>]'
 '</span>' % form.req._('view all'))
 w(u'<li class="invisible">%s</li>' % link)
 w(u'</ul>')
 w(u'</td>')
 w(u'</th>')
 w(u'<td id="unrelatedDivs_%s"></td>' % eid)
 w(u'</tr>')
 w(u'</table>')
 w(u'</fieldset>')
 def inline_entities_form(self, w, form):
 """create a form to edit entity's inlined relations"""
 entity = form.edited_entity
 __ = form.req.__
 for rschema, targettypes, role in form.inlined_relations():
 if form.should_inline_relation_form(rschema, targettype, role):
 w(u'<div id="inline%sslot">' % rschema)
 existant = entity.has_eid() and entity.related(rschema)
 if existant:
 # display inline-edition view for all existing related entities
 w(form.view('inline-edition', existant, rtype=rschema, role=role,
 ptype=entity.e_schema, peid=entity.eid))
 if role == 'subject':
 card = rschema.rproperty(entity.e_schema, targettype, 'cardinality')[0]
 else:
 card = rschema.rproperty(targettype, entity.e_schema, 'cardinality')[1]
 % (rschema, entity.eid, js, __('add a %s' % targettype)))
 w(u'</div>')
 w(u'<div class="trame_grise">&nbsp;</div>')
 w(u'</div>')
 class EntityInlinedFormRenderer(EntityFormRenderer):
 """specific renderer for entity inlined edition form
 (inline-[creation|edition])
 """
 def render(self, form, values):
 '[<a href="javascript: %(removejs)s;noop();">%(removemsg)s</a>]</div>'
 % values)
 self.render_fields(w, form, values)
 w(u'</div></div>')
 return '\n'.join(data)
 def render_fields(self, w, form, values):
 form.form_build_context(values)
 w(u'<fieldset id="fs-%(divid)s">' % values)
 fields = self._render_hidden_fields(w, form)
 w(u'</fieldset>')
 if fields:
 self._render_fields(fields, w, form)
 self.render_child_forms(w, form, values)
 self.inline_entities_form(w, form)
 w(u'</fieldset>')

branch	tls-sprint
changeset 1436	97774eb6443b
parent 1434	42e57dbbc585
child 1576	3bfcf1e4eb26