def crispy_addon(field, append="", prepend=""):
"""
Renders a form field using bootstrap's prepended or appended text::
{% crispy_addon form.my_field prepend="$" append=".00" %}
You can also just prepend or append like so
{% crispy_addon form.my_field prepend="$" %}
{% crispy_addon form.my_field append=".00" %}
"""
if (field):
context = Context({
'field': field,
'form_show_errors': True
})
template = loader.get_template('%s/layout/prepended_appended_text.html' % get_template_pack())
context['crispy_prepended_text'] = prepend
context['crispy_appended_text'] = append
if not prepend and not append:
raise TypeError("Expected a prepend and/or append argument")
return template.render(context)
def __init__(self, form, helper, template_pack=None):
self.form = form
if helper is not None:
self.helper = helper
else:
self.helper = None
self.template_pack = template_pack or get_template_pack()
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
html = u""
errors = self._get_errors(form, self.fields)
if len(errors) > 0:
self.css_class += " has-error"
for field in self.fields:
html += render_field(field, form, form_style, context, template_pack=template_pack)
context.update(
{
"label_html": mark_safe(self.label_html),
"field_html": mark_safe(html),
"multifield": self,
"error_list": errors,
"help_bubble_text": self.help_bubble_text,
}
)
if not (self.field_class or self.label_class):
return render_to_string(self.template, context)
with edited_classes(context, self.label_class, self.field_class):
rendered_view = render_to_string(self.template, context)
return rendered_view
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
self.template = "style/crispy/{}/{}".format(template_pack, self.template)
context.update({
'help_bubble_text': self.help_bubble_text,
})
return super(FieldWithHelpBubble, self).render(form, form_style, context, template_pack=template_pack)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
context.update({
'field_label': self.field_label,
'field_value': self.field_value,
})
return render_to_string(self.template, context)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
offsets = _get_offsets(context)
context.update({
'offsets': offsets,
})
return super(Field, self).render(form, form_style, context, template_pack)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
offsets = _get_offsets(context)
context.update({
'offsets': offsets,
})
return super(Field, self).render(form, form_style, context, template_pack)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
context.update({
'field_label': self.field_label,
'field_value': self.field_value,
})
return render_to_string(self.template, context.flatten())
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
context.update({
'field_text': self.text,
})
return super(TextField, self).render(form, form_style, context,
template_pack=template_pack)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
html = ''
errors = self._get_errors(form, self.fields)
if len(errors) > 0:
self.css_class += " has-error"
for field in self.fields:
html += render_field(field, form, form_style, context, template_pack=template_pack)
context.update({
'label_html': mark_safe(self.label_html),
'field_html': mark_safe(html),
'multifield': self,
'error_list': errors,
'help_bubble_text': self.help_bubble_text,
})
context_dict = context.flatten()
if not (self.field_class or self.label_class):
return render_to_string(self.template, context_dict)
with edited_classes(context, self.label_class, self.field_class):
rendered_view = render_to_string(self.template, context_dict)
return rendered_view
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
html = ''
errors = self._get_errors(form, self.fields)
if len(errors) > 0:
self.css_class += " has-error"
for field in self.fields:
html += render_field(field,
form,
form_style,
context,
template_pack=template_pack)
context.update({
'label_html': mark_safe(self.label_html),
'field_html': mark_safe(html),
'multifield': self,
'error_list': errors,
'help_bubble_text': self.help_bubble_text,
})
context_dict = context.flatten()
if not (self.field_class or self.label_class):
return render_to_string(self.template, context_dict)
with edited_classes(context, self.label_class, self.field_class):
rendered_view = render_to_string(self.template, context_dict)
return rendered_view
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
html = u''
errors = self._get_errors(form, self.fields)
if len(errors) > 0:
self.css_class += " has-error"
for field in self.fields:
html += render_field(field, form, form_style, context, template_pack=template_pack)
context.update({
'label_html': mark_safe(self.label_html),
'field_html': mark_safe(html),
'multifield': self,
'error_list': errors,
'help_bubble_text': self.help_bubble_text,
})
if isinstance(context, RequestContext):
context_dict = context.flatten()
else:
# TODO - remove by Nov 1 2017 if soft assert is never sent
_soft_assert_dict(False, "context is type %s" % str(type(context)))
context_dict = context
if not (self.field_class or self.label_class):
return render_to_string(self.template, context_dict)
with edited_classes(context, self.label_class, self.field_class):
rendered_view = render_to_string(self.template, context_dict)
return rendered_view
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
context.update({
'field_text': self.text,
})
return super(TextField, self).render(form, form_style, context,
template_pack=template_pack)
def crispy_addon(field, append="", prepend="", form_show_labels=True):
"""
Renders a form field using bootstrap's prepended or appended text::
{% crispy_addon form.my_field prepend="$" append=".00" %}
You can also just prepend or append like so
{% crispy_addon form.my_field prepend="$" %}
{% crispy_addon form.my_field append=".00" %}
"""
if field:
context = Context({
"field": field,
"form_show_errors": True,
"form_show_labels": form_show_labels
})
template = loader.get_template(
"%s/layout/prepended_appended_text.html" % get_template_pack())
context["crispy_prepended_text"] = prepend
context["crispy_appended_text"] = append
if not prepend and not append:
raise TypeError("Expected a prepend and/or append argument")
context = context.flatten()
return template.render(context)
def crispy_addon(field, append="", prepend="", form_show_labels=True):
"""
Renders a form field using bootstrap's prepended or appended text::
{% crispy_addon form.my_field prepend="$" append=".00" %}
You can also just prepend or append like so
{% crispy_addon form.my_field prepend="$" %}
{% crispy_addon form.my_field append=".00" %}
"""
if field:
context = Context({
'field': field,
'form_show_errors': True,
'form_show_labels': form_show_labels,
})
template = loader.get_template(
'%s/layout/prepended_appended_text.html' % get_template_pack())
context['crispy_prepended_text'] = prepend
context['crispy_appended_text'] = append
if not prepend and not append:
raise TypeError("Expected a prepend and/or append argument")
if django.VERSION >= (1, 8):
context = context.flatten()
return template.render(context)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
context.update({
'block_css_class': self.block_css_class,
})
return super(InlineColumnField, self).render(
form, form_style, context, template_pack=template_pack
)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
context.update({
'block_css_class': self.block_css_class,
})
return super(InlineColumnField, self).render(
form, form_style, context, template_pack=template_pack
)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
template = self.template.format(template_pack=template_pack)
context.update({
'button_text': self.button_text,
'button_url': self.button_url,
'button_attrs': flatatt(self.attrs if isinstance(self.attrs, dict) else {}),
})
return render_to_string(template, context)
def do_uni_form(parser, token):
"""
You need to pass in at least the form/formset object, and can also pass in the
optional `crispy_forms.helpers.FormHelper` object.
helper (optional): A `crispy_forms.helper.FormHelper` object.
Usage::
{% load crispy_tags %}
{% crispy form form.helper %}
You can also provide the templates pack as the third argument::
{% crispy form form.helper 'bootstrap' %}
If the `FormHelper` attribute is named `helper` you can simply do::
{% crispy form %}
{% crispy form 'bootstrap' %}
"""
token = token.split_contents()
form = token.pop(1)
helper = None
template_pack = "'%s'" % get_template_pack()
# {% crispy form helper %}
try:
helper = token.pop(1)
except IndexError:
pass
# {% crispy form helper 'bootstrap' %}
try:
template_pack = token.pop(1)
except IndexError:
pass
# {% crispy form 'bootstrap' %}
if helper is not None and isinstance(helper, str) and ("'" in helper
or '"' in helper):
template_pack = helper
helper = None
if template_pack is not None:
template_pack = template_pack[1:-1]
ALLOWED_TEMPLATE_PACKS = getattr(
settings, "CRISPY_ALLOWED_TEMPLATE_PACKS",
("bootstrap", "uni_form", "bootstrap3", "bootstrap4"))
if template_pack not in ALLOWED_TEMPLATE_PACKS:
raise template.TemplateSyntaxError(
"crispy tag's template_pack argument should be in %s" %
str(ALLOWED_TEMPLATE_PACKS))
return CrispyFormNode(form, helper, template_pack=template_pack)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
context.update({
'help_bubble_text': self.help_bubble_text,
})
return super(FieldWithHelpBubble,
self).render(form,
form_style,
context,
template_pack=template_pack)
def render(self, context):
# Nodes are not threadsafe so we must store and look up our instance
# variables in the current rendering context first
if self not in context.render_context:
context.render_context[self] = (
template.Variable(self.field),
self.attrs,
template.Variable(self.html5_required)
)
field, attrs, html5_required = context.render_context[self]
field = field.resolve(context)
try:
html5_required = html5_required.resolve(context)
except template.VariableDoesNotExist:
html5_required = False
widgets = getattr(field.field.widget, 'widgets', [field.field.widget])
if isinstance(attrs, dict):
attrs = [attrs] * len(widgets)
for widget, attr in zip(widgets, attrs):
class_name = widget.__class__.__name__.lower()
class_name = class_converter.get(class_name, class_name)
css_class = widget.attrs.get('class', '')
if css_class:
if css_class.find(class_name) == -1:
css_class += " %s" % class_name
else:
css_class = class_name
if (
get_template_pack() == 'bootstrap3'
and not is_checkbox(field)
and not is_file(field)
):
css_class += ' form-control'
widget.attrs['class'] = css_class
# HTML5 required attribute
if html5_required and field.field.required and 'required' not in widget.attrs:
if field.field.widget.__class__.__name__ is not 'RadioSelect':
widget.attrs['required'] = 'required'
for attribute_name, attribute in attr.items():
attribute_name = template.Variable(attribute_name).resolve(context)
if attribute_name in widget.attrs:
widget.attrs[attribute_name] += " " + template.Variable(attribute).resolve(context)
else:
widget.attrs[attribute_name] = template.Variable(attribute).resolve(context)
return field
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
html = u''
for field in self.fields:
html += render_field(field, form, form_style, context, template_pack=template_pack)
context.update({
'label_html': mark_safe(self.label_html),
'field_html': mark_safe(html),
'multifield': self,
})
return render_to_string(self.template, context)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
html = u''
for field in self.fields:
html += render_field(field, form, form_style, context, template_pack=template_pack)
offsets = _get_offsets(context)
return render_to_string(self.template, Context({
'formactions': self,
'fields_output': html,
'offsets': offsets,
'field_class': context.get('field_class', '')
}))
def do_uni_form(parser, token):
"""
You need to pass in at least the form/formset object, and can also pass in the
optional `crispy_forms.helpers.FormHelper` object.
helper (optional): A `crispy_forms.helper.FormHelper` object.
Usage::
{% include crispy_tags %}
{% crispy form form.helper %}
You can also provide the template pack as the third argument::
{% crispy form form.helper 'bootstrap' %}
If the `FormHelper` attribute is named `helper` you can simply do::
{% crispy form %}
{% crispy form 'bootstrap' %}
"""
token = token.split_contents()
form = token.pop(1)
try:
helper = token.pop(1)
except IndexError:
helper = None
try:
# {% crispy form helper 'bootstrap' %}
template_pack = token.pop(1)
if not (template_pack[0] == template_pack[-1] and template_pack[0] in ('"', "'")):
raise template.TemplateSyntaxError("crispy tag's template_pack argument should be in quotes")
template_pack = template_pack[1:-1]
if template_pack not in ALLOWED_TEMPLATE_PACKS:
raise template.TemplateSyntaxError("crispy tag's template_pack argument should be \
in " + str(ALLOWED_TEMPLATE_PACKS))
except IndexError:
# {% crispy form 'bootstrap' %}
# ('"'bootstrap'"', '"'uni_form'"','"'"bootstrap'"'", '"'"uni_form"'")
if (
helper in ['"%s"' % x for x in ALLOWED_TEMPLATE_PACKS] + \
["'%s'" % x for x in ALLOWED_TEMPLATE_PACKS]
):
template_pack = helper[1:-1]
helper = None
# {% crispy form helper %} OR {% crispy form %}
else:
template_pack = get_template_pack()
return CrispyFormNode(form, helper, template_pack=template_pack)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
html = u''
for field in self.fields:
html += render_field(field, form, form_style, context, template_pack=template_pack)
offsets = _get_offsets(context)
return render_to_string(self.template, Context({
'formactions': self,
'fields_output': html,
'offsets': offsets,
'field_class': context.get('field_class', '')
}))
def __init__(self, *args, **kwargs):
# Map template packs to the css class they need here.
# TODO: This is a _Smell_. There should be a factory which creates a
# template pack specific subclass. (Or such...)
row_class_map = {
'uni_form': 'formRow',
'bootstrap4': 'form-row',
'bootstrap3': 'row',
}
# Fetch the class, with a suitable default.
self.css_class = row_class_map.get(get_template_pack(), 'row')
super(Row, self).__init__(*args, **kwargs)
def get_response_dict(self, helper, context, is_formset):
"""
Returns a dictionary with all the parameters necessary to render the form/formset in a template.
:param attrs: Dictionary with the helper's attributes used for rendering the form/formset
:param context: `django.template.Context` for the node
:param is_formset: Boolean value. If set to True, indicates we are working with a formset.
"""
if not isinstance(helper, FormHelper):
raise TypeError('helper object provided to {% crispy %} tag must be a crispy.helper.FormHelper object.')
attrs = helper.get_attributes(template_pack=self.template_pack)
form_type = "form"
if is_formset:
form_type = "formset"
# We take form/formset parameters from attrs if they are set, otherwise we use defaults
response_dict = {
'template_pack': get_template_pack(),
'%s_action' % form_type: attrs['attrs'].get("action", ''),
'%s_method' % form_type: attrs.get("form_method", 'post'),
'%s_tag' % form_type: attrs.get("form_tag", True),
'%s_class' % form_type: attrs['attrs'].get("class", ''),
'%s_id' % form_type: attrs['attrs'].get("id", ""),
'%s_style' % form_type: attrs.get("form_style", None),
'form_error_title': attrs.get("form_error_title", None),
'formset_error_title': attrs.get("formset_error_title", None),
'form_show_errors': attrs.get("form_show_errors", True),
'help_text_inline': attrs.get("help_text_inline", False),
'html5_required': attrs.get("html5_required", False),
'form_show_labels': attrs.get("form_show_labels", True),
'disable_csrf': attrs.get("disable_csrf", False),
'inputs': attrs.get('inputs', []),
'is_formset': is_formset,
'%s_attrs' % form_type: attrs.get('attrs', ''),
'flat_attrs': attrs.get('flat_attrs', ''),
'error_text_inline': attrs.get('error_text_inline', True),
'label_class': attrs.get('label_class', ''),
'label_size': attrs.get('label_size', 0),
'field_class': attrs.get('field_class', ''),
}
# Handles custom attributes added to helpers
for attribute_name, value in attrs.items():
if attribute_name not in response_dict:
response_dict[attribute_name] = value
if 'csrf_token' in context:
response_dict['csrf_token'] = context['csrf_token']
return response_dict
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
context.update({
'field_text': self.text,
})
if hasattr(self, 'wrapper_class'):
context['wrapper_class'] = self.wrapper_class
html = ''
for field in self.fields:
html += render_field(field, form, form_style, context,
template=self.template, attrs=self.attrs,
template_pack=template_pack)
return html
def bs4_appended_prepended_text(field,
append="",
prepend="",
form_show_labels=True):
"""
Similar to the `crispy_addon` tag. However, this one respects classes that
have been set in the corresponding Form layout object.
"""
template_pack = get_template_pack()
if template_pack != "bootstrap4":
raise CrispyError(
"bs4_appended_prepended_text can only be used with Bootstrap 4")
if field:
attributes = {
'field': field,
'form_show_errors': True,
'form_show_labels': form_show_labels,
}
helper = getattr(field.form, "helper", None)
if helper is not None:
attributes.update(helper.get_attributes(get_template_pack()))
context = Context(attributes)
template = loader.get_template(
"%s/layout/prepended_appended_text.html" % get_template_pack())
context["crispy_prepended_text"] = prepend
context["crispy_appended_text"] = append
if not prepend and not append:
raise TypeError("Expected a prepend and/or append argument")
context = context.flatten()
return template.render(context)
def render(self, context):
try:
template_pack = template.Variable('template_pack').resolve(context)
except:
template_pack = get_template_pack()
try:
form_attrs = template.Variable('form_attrs').resolve(context)
except:
form_attrs = {}
return selectively_remove_spaces_between_tags(
self.nodelist.render(context).strip(),
template_pack,
form_attrs.get('class', ''),
)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
html = u""
for field in self.fields:
html += render_field(field, form, form_style, context, template_pack=template_pack)
offsets = _get_offsets(context)
return render_to_string(
self.template,
Context(
{
"formactions": self,
"fields_output": html,
"offsets": offsets,
"field_class": context.get("field_class", ""),
}
),
)
def as_crispy_field(field, template_pack=None):
"""
Renders a form field like a django-crispy-forms field::
{% load crispy_forms_tags %}
{{ form.field|as_crispy_field }}
or::
{{ form.field|as_crispy_field:"bootstrap" }}
"""
template_pack = template_pack or get_template_pack()
if not isinstance(field, forms.BoundField) and DEBUG:
raise CrispyError('|as_crispy_field got passed an invalid or inexistent field')
template = get_template('%s/field.html' % template_pack)
c = Context({'field': field, 'form_show_errors': True, 'form_show_labels': True})
return template.render(c)
def as_crispy_errors(form, template_pack=None):
"""
Renders only form errors the same way as django-crispy-forms::
{% load crispy_forms_tags %}
{{ form|as_crispy_errors }}
or::
{{ form|as_crispy_errors:"bootstrap" }}
"""
template_pack = template_pack or get_template_pack()
if isinstance(form, BaseFormSet):
template = get_template('%s/errors_formset.html' % template_pack)
c = Context({'formset': form})
else:
template = get_template('%s/errors.html' % template_pack)
c = Context({'form': form})
return template.render(c)
def crispy_addon(field, append="", prepend="", form_show_labels=True):
"""
Renders a form field using bootstrap's prepended or appended text::
{% crispy_addon form.my_field prepend="$" append=".00" %}
You can also just prepend or append like so
{% crispy_addon form.my_field prepend="$" %}
{% crispy_addon form.my_field append=".00" %}
"""
if field:
context = Context({"field": field, "form_show_errors": True, "form_show_labels": form_show_labels})
template = loader.get_template("%s/layout/prepended_appended_text.html" % get_template_pack())
context["crispy_prepended_text"] = prepend
context["crispy_appended_text"] = append
if not prepend and not append:
raise TypeError("Expected a prepend and/or append argument")
return template.render(context)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
fields_output = u''
for field in self.fields:
fields_output += render_field(
field, form, form_style, context,
self.field_template, self.label_class, layout_object=self,
template_pack=template_pack
)
errors = self._get_errors(form, self.fields)
if len(errors) > 0:
self.css_class += " error"
context.update({
'multifield': self,
'fields_output': fields_output,
'error_list': errors,
'help_bubble_text': self.help_bubble_text,
})
return render_to_string(self.template, context)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
fields_output = u''
for field in self.fields:
fields_output += render_field(
field, form, form_style, context,
self.field_template, self.label_class, layout_object=self,
template_pack=template_pack
)
errors = self._get_errors(form, self.fields)
if len(errors) > 0:
self.css_class += " error"
context.update({
'multifield': self,
'fields_output': fields_output,
'error_list': errors,
'help_bubble_text': self.help_bubble_text,
})
return render_to_string(self.template, context)
def as_crispy_form(form, template_pack=None, label_class="", field_class=""):
"""
The original and still very useful way to generate a div elegant form/formset::
{% load crispy_forms_tags %}
<form class="uniForm" method="post">
{% csrf_token %}
{{ myform|crispy }}
</form>
or, if you want to explicitly set the template pack::
{{ myform|crispy:"bootstrap" }}
In ``bootstrap3`` for horizontal forms you can do::
{{ myform|label_class:"col-lg-2",field_class:"col-lg-8" }}
"""
template_pack = template_pack or get_template_pack()
if isinstance(form, BaseFormSet):
template = uni_formset_template(template_pack)
c = Context({
'formset': form,
'form_show_errors': True,
'form_show_labels': True,
'label_class': label_class,
'field_class': field_class,
})
else:
template = uni_form_template(template_pack)
c = Context({
'form': form,
'form_show_errors': True,
'form_show_labels': True,
'label_class': label_class,
'field_class': field_class,
})
return template.render(c)
def __init__(self, *args, **kwargs):
self.field_classes = 'button' if get_template_pack() == 'uni_form' else 'btn'
super(Button, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.field_classes = 'reset resetButton' if get_template_pack() == 'uni_form' else 'btn btn-inverse'
super(Reset, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.css_class = 'formRow' if get_template_pack() == 'uni_form' else 'row'
super(Row, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.field_classes = "reset resetButton" if get_template_pack(
) == "uni_form" else "btn btn-inverse"
super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.field_classes = "button" if get_template_pack(
) == "uni_form" else "btn"
super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.field_classes = 'button' if get_template_pack(
) == 'uni_form' else 'btn'
super(Button, self).__init__(*args, **kwargs)
def do_uni_form(parser, token):
"""
You need to pass in at least the form/formset object, and can also pass in the
optional `crispy_forms.helpers.FormHelper` object.
helper (optional): A `crispy_forms.helper.FormHelper` object.
Usage::
{% load crispy_tags %}
{% crispy form form.helper %}
You can also provide the template pack as the third argument::
{% crispy form form.helper 'bootstrap' %}
If the `FormHelper` attribute is named `helper` you can simply do::
{% crispy form %}
{% crispy form 'bootstrap' %}
"""
token = token.split_contents()
form = token.pop(1)
helper = None
template_pack = "'%s'" % get_template_pack()
# {% crispy form helper %}
try:
helper = token.pop(1)
except IndexError:
pass
# {% crispy form helper 'bootstrap' %}
try:
template_pack = token.pop(1)
except IndexError:
pass
# {% crispy form 'bootstrap' %}
if (
helper is not None and
isinstance(helper, string_types) and
("'" in helper or '"' in helper)
):
template_pack = helper
helper = None
if template_pack is not None:
template_pack = template_pack[1:-1]
ALLOWED_TEMPLATE_PACKS = getattr(
settings,
'CRISPY_ALLOWED_TEMPLATE_PACKS',
('bootstrap', 'uni_form', 'bootstrap3', 'bootstrap4')
)
if template_pack not in ALLOWED_TEMPLATE_PACKS:
raise template.TemplateSyntaxError(
"crispy tag's template_pack argument should be in %s" %
str(ALLOWED_TEMPLATE_PACKS)
)
return CrispyFormNode(form, helper, template_pack=template_pack)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
self.template = self.template.format(template_pack=template_pack)
return super(HiddenFieldWithErrors, self).render(form, form_style, context, template_pack)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
self.template = self.template.format(template_pack=template_pack)
return super(FieldsetAccordionGroup, self).render(form, form_style, context, template_pack)
def render(self, form, form_style, context, template_pack=None):
template_pack = template_pack or get_template_pack()
context.update({
'help_bubble_text': self.help_bubble_text,
})
return super(FieldWithHelpBubble, self).render(form, form_style, context, template_pack=template_pack)
def __init__(self, *args, **kwargs):
self.field_classes = 'submit submitButton' if get_template_pack(
) == 'uni_form' else 'btn btn-primary'
super(Submit, self).__init__(*args, **kwargs)
def crispy_html(context, layout):
return mark_safe(
layout.render({}, (), context, template_pack=get_template_pack()))
def __init__(self, *args, **kwargs):
self.css_class = 'formRow' if get_template_pack() == 'uni_form' else 'row'
super(Row, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.field_classes = "submit submitButton" if get_template_pack(
) == "uni_form" else "btn btn-primary"
super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.field_classes = 'reset resetButton' if get_template_pack(
) == 'uni_form' else 'btn btn-inverse'
super(Reset, self).__init__(*args, **kwargs)
