Comment définir la classe css d'une étiquette dans une déclaration de formulaire django?

Je suis en utilisant django-uniforme et à l'utilisation de certains uniformes de fonctionnalités, je suis à la recherche d'un moyen d'ajouter de la classe css directement à partir du formulaire de déclaration (pour les indépendants widgets).

(comme un bonus, voici mon réutilisables en lecture seule à la maison fait mixin extrait...)

from django import forms

def _get_cleaner(form, field):
    def clean_field():
        return getattr(form.instance, field, None)
    return clean_field

class UniformROMixin(forms.BaseForm):
    """
    UniformROMixin, inherits to turn some fields read only

      - read_only = list of field names.
    """

    def __init__(self, *args, **kwargs):
        super(UniformROMixin, self).__init__(*args, **kwargs)
        if hasattr(self, "read_only"):
            if self.instance and self.instance.pk:
                for field in self.read_only:
                    self.fields[field].widget.attrs['readonly'] = True
                    self.fields[field].widget.attrs['class'] += "readOnly"
                    # here I would like to set css class of the label
                    # created from the self.fields[field].label string
                    setattr(self, "clean_" + field, _get_cleaner(self, field))

Mon seul moyen pour l'instant est d'ajouter un peu de javascript sur mon formulaire générique de modèle et ajouter des classes à la main.

Tout brillant comme idée?

source d'informationauteur christophe31

  1. 18

    Widgets ont un attrs argument mot-clé que prendre un dict qui peut définir des attributs pour l'élément d'entrée qu'il rend. Les formes ont aussi certains attributs que vous pouvez définir pour modifier la façon dont Django affiche votre formulaire. Prenons l'exemple suivant:

    class MyForm(forms.Form):
    error_css_class = 'error'
    required_css_class = 'required'
    my_field = forms.CharField(max_length=10,
                               widget=forms.TextInput(attrs={'id': 'my_field',
                                                             'class': 'my_class'}))

    Cela fonctionne sur n'importe quel Widget classe. Malheureusement, il n'y a pas un moyen facile de changer la façon dont Django rend les étiquettes si vous venez de le faire {{ field }}. Heureusement, vous jouez avec la forme de l'objet un peu dans le modèle:

    <form>
    {% for field in form %}
        <label class="my_class" for="{{ field.name }}">{{ field.label }}</label>
        {{ field }}
    {% endfor %}
    <button type="submit">Submit</button>
</form>

    Là encore, vous pouvez toujours ajouter arbitraire des attributs de l'objet sur lequel vous travaillez:

    # In a view...
form = MyForm()
form.label_classes = ('class_a', 'class_b', )
# Or by hijacking ```__init__```
class MyForm(forms.Form):
    def __init__(self, *args, **kwargs):
        self.my_field = forms.CharField(max_length=10,
                                        widget=forms.TextInput(attrs={'id': 'my_field',
                                                                      'class': 'my_class'}))
        self.my_field.label_classes = ('class_a', 'class_b', )
        super(MyForm, self).__init__(*args, **kwargs)

    Rendre votre modèle avec la forme en contexte, et dans le modèle, vous pouvez le faire:

    <form>
    {% for field in form %}
        <label class="{% for class in field.label_classes %}{{ class }} {% endfor %}"
               for="{{ field.name }}">{{ field.label }}</label>
        {{ field }}
    {% endfor %}
    <button type="submit">Submit</button>
</form>

    Ce qui convient à votre fantaisie.

  2. 3

    J'ai trouvé cet extrait de code qui pourrait être une bonne réponse:

    Comment ajouter de la classe css et "*" pour les champs requis étiquettes

    ici une adaptation à mes besoins (pas encore testé, je vais modifier le post une fois fait):

    from django.utils.html import escape

def readonly_cssclass_adder(bound_field, label_content, label_attrs):
    if 'readonly' in bound_field.field.widget.attrs:
        if 'class' in attrs:
            label_attrs['class'] += " readOnly"
        else:
            label_attrs['class'] = "readOnly"
    return label_content, label_attrs


def add_required_label_tag(original_function, tweak_foos=None):
    if not tweak_foos:
        return original_function

    def required_label_tag(self, contents=None, attrs=None):
        contents = contents or escape(self.label)
        if attrs is None:
            attrs = {}
        for foo in tweak_foos:
            contents, attrs = foo(self, contents, attrs)
        return original_function(self, contents, attrs)
    return required_label_tag

def decorate_bound_field():
    from django.forms.forms import BoundField
    BoundField.label_tag = add_required_label_tag(BoundField.label_tag, 
                                           tweak_foos=[readonly_cssclass_adder])

    Si vous avez une meilleure solution à ne pas le tordre tous les BoundField classe je suis toujours à l'écoute.

    edit:
    peut être lié à django de façon uniforme pour gérer champ obligatoire mais il semble ne pas appeler readonly_cssclass_adder. Mais j'ai trouvé un autre et plus simple solution, mon readOnly widget activé automatiquement en lecture seule ctrlHolder

    Cet ajout est mon préféré de réponse pour l'instant:

    edit 2: L'autre manière de choisir à la fin de l'été pour "contourner" le uni_form/field.html modèle qui n'appelez pas BoundField.label_tag. Donc j'ai vérifié ici domaine de l'état.

    <label for="{{ field.auto_id }}"{% if field.field.required %}
       class="requiredField{% if field.widget.attrs.readonly %} readOnlyLabel{% endif %}"
       {% else %}{% if field.widget.attrs.readonly %}class="readOnlyLabel"{% endif %}{% endif %}>
    {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
</label>
  3. 0

    Légèrement personnalisée option basée sur @xj9 solution utilisée avec ManyToMany champ et Bootstrap .checkbox-inline. Fonctionne comme le bouton radio avec .radio-inline.

    form.py

    class MyForm(forms.ModelForm): 
    def __init__(self, *args, **kwargs):
        super(MyForm, self).__init__(*args, **kwargs)

self.fields['m2mfield'] = forms.ModelMultipleChoiceField(
                                queryset=Model.objects.all().order_by('name'),
                                required=True,
                                widget=forms.CheckboxSelectMultiple())

    template.html

    <div class="col-sm-9">
{% for field in form.m2mfield %}
    <label class="checkbox-inline" for="{{ field.name }}">{{ field.label }}</label>
    {{ field }}
{% endfor %}
</div>