Refs #7864 -- Corrected more instances of "newforms" in the docs.

Keep in mind that this will be prepended with ``MEDIA_URL``. The same rules

apply as `regular media definitions on forms`_.

.. _regular media definitions on forms: ../newforms/#media

.. _regular media definitions on forms: ../forms/#media

``InlineModelAdmin`` objects

============================

This controls the number of extra forms the formset will display in addition

to the initial forms. See the `formsets documentation`_ for more information.

.. _formsets documentation: ../newforms/#formsets

.. _formsets documentation: ../forms/#formsets

``max_num``

~~~~~~~~~~~

page. It can be best compared to a data grid. Let's say you have the following

form::

    >>> from django import newforms as forms

    >>> from django import forms

    >>> class ArticleForm(forms.Form):

    ...     title = forms.CharField()

    ...     pub_date = forms.DateField()

You might want to allow the user to create several articles at once. To create

a formset of out of an ``ArticleForm`` you would do::

    >>> from django.newforms.formsets import formset_factory

    >>> from django.forms.formsets import formset_factory

    >>> ArticleFormSet = formset_factory(ArticleForm)

You now have created a formset named ``ArticleFormSet``. The formset gives you

    >>> formset = ArticleFormSet(data)

    Traceback (most recent call last):

    ...

    django.newforms.util.ValidationError: [u'ManagementForm data is missing or has been tampered with']

    django.forms.util.ValidationError: [u'ManagementForm data is missing or has been tampered with']

It is used to keep track of how many form instances are being displayed. If

you are adding new forms via javascript, you should increment the count fields

A formset has a ``clean`` method similar to the one on a ``Form`` class. This

is where you define your own validation that deals at the formset level::

    >>> from django.newforms.formsets import BaseFormSet

    >>> from django.forms.formsets import BaseFormSet

    >>> class BaseArticleFormSet(BaseFormSet):

    ...     def clean(self):

**Changed in Django development version:**

``django.views.generic.create_update.create_object`` and

``django.views.generic.create_update.update_object`` now use `newforms`_ to

build and display the form.

``django.views.generic.create_update.update_object`` now use the new `forms

library`_ to build and display the form.

.. _newforms: ../newforms/

.. _forms library: ../forms/

``django.views.generic.create_update.create_object``

----------------------------------------------------

    * Either ``form_class`` or ``model`` is required.

      If you provide ``form_class``, it should be a

      ``django.newforms.ModelForm`` subclass.  Use this argument when you need

      ``django.forms.ModelForm`` subclass.  Use this argument when you need

      to customize the model's form.  See the `ModelForm docs`_ for more

      information.

In addition to ``extra_context``, the template's context will be:

    * ``form``: A ``django.newforms.ModelForm`` instance representing the form

    * ``form``: A ``django.forms.ModelForm`` instance representing the form

      for creating the object. This lets you refer to form fields easily in the

      template system.

      ``Form`` objects in templates.

.. _authentication system: ../authentication/

.. _ModelForm docs: ../newforms/modelforms

.. _ModelForm docs: ../forms/modelforms

.. _forms documentation: ../forms/

``django.views.generic.create_update.update_object``

    * Either ``form_class`` or ``model`` is required.

      If you provide ``form_class``, it should be a

      ``django.newforms.ModelForm`` subclass.  Use this argument when you need

      ``django.forms.ModelForm`` subclass.  Use this argument when you need

      to customize the model's form.  See the `ModelForm docs`_ for more

      information.

In addition to ``extra_context``, the template's context will be:

    * ``form``: A ``django.newforms.ModelForm`` instance representing the form

    * ``form``: A ``django.forms.ModelForm`` instance representing the form

      for editing the object. This lets you refer to form fields easily in the

      template system.

          <p>{{ form.address.label_tag }} {{ form.address }}</p>

          </form>

      See the `newforms documentation`_ for more information about using

      See the `forms documentation`_ for more information about using

      ``Form`` objects in templates.

    * ``object``: The original object being edited. This variable's name

provide all the right things to work with your models. Lets reuse the

``Author`` model from above::

    >>> from django.newforms.models import modelformset_factory

    >>> from django.forms.models import modelformset_factory

    >>> AuthorFormSet = modelformset_factory(Author)

This will create a formset that is capable of working with the data associated

Alternatively, you can use a subclassing based approach::

    from django.newforms.models import BaseModelFormSet

    from django.forms.models import BaseModelFormSet

    class BaseAuthorFormSet(BaseModelFormSet):

        def get_queryset(self):

``Author`` and ``Book``. You want to create a formset that works with the

books of a specific author. Here is how you could accomplish this::

    >>> from django.newforms.models import inlineformset_factory

    >>> from django.forms.models import inlineformset_factory

    >>> BookFormSet = inlineformset_factory(Author, Book)

    >>> author = Author.objects.get(name=u'Orson Scott Card')

    >>> formset = BookFormSet(instance=author)

    rendered on the form.

    ``form`` is the name the ``Form`` instance was given in the template

    context. Note that this works only for ``newforms.Form`` instances, not

    context. Note that this works only for ``forms.Form`` instances, not

    ``oldforms.Form`` instances.

    ``field`` is the name of the field on the form to check. If ``field``