Metadata-Version: 1.1
Name: plone.autoform
Version: 1.6
Summary: Tools to construct z3c.form forms
Home-page: http://code.google.com/p/dexterity
Author: Martin Aspeli
Author-email: optilude@gmail.com
License: LGPL
Description: plone.autoform
        ==============
        
        .. contents:: Contents
        
        Introduction
        ------------
        
        ``plone.autoform`` builds custom `z3c.form`_ forms based on a model (schema)
        of what fields to include and what widgets and options should be used for each
        field. This model is defined as a `zope.schema`_-based schema, but additional
        hints can be supplied to control aspects of form display not normally specified
        in a Zope schema.
        
        
        Basic schema-based forms
        ------------------------
        
        To use the automatic form setup, mix in the following base class in your
        forms::
        
            >>> from plone.autoform.form import AutoExtensibleForm
        
        and then provide the ``schema`` (a schema interface) and optionally the
        ``additionalSchemata`` (a list of schema interfaces) attributes on your form::
        
            class MyForm(AutoExtensibleForm, form.EditForm):
                schema = IMySchema
                additionalSchemata = (ISchemaOne, ISchemaTwo,)
                # ...
        
        For dynamic forms, you could of course make ``schema`` and
        ``additionalSchemata`` into properties. For example, `plone.dexterity`_ extends the
        basic AutoExtensibleForm so that ``schema`` is the content type schema and
        ``additionalSchemata`` is a list of field provider schemas associated with
        behaviors.
        
        
        Controlling form presentation
        -----------------------------
        
        Directives can be specified in the schema to control aspects of form presentation.
        
        Changing a field's display mode
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        A field's widget can be displayed in several "modes":
        
        * input - allows the user to enter data into the field
        * display - a read-only indication of the field's value
        * hidden - a record of the field's value that is included only in the HTML source
        
        The mode can be controlled using the ``mode`` directive::
        
            from plone.supermodel import model
            from plone.autoform import directives as form
        
            class IMySchema(model.Schema):
            
                form.mode(secret='hidden')
                form.mode(IEditForm, secret='input')
                secret = schema.TextLine(
                    title=u"Secret",
                    default=u"Secret stuff (except on edit forms)"
                    )
        
        In this case the mode for the ``secret`` field is set to 'hidden' for most forms,
        but 'input' for forms that provide the IEditForm interface.
        
        The corresponding supermodel XML directive is ``form:mode``::
        
            <field type="zope.schema.TextLine"
                    name="secret"
                    form:mode="z3c.form.interfaces.IForm:hidden z3c.form.interfaces.IEditForm:input">
                <title>Secret</title>
                <description>Secret stuff (except on edit forms)</description>
            </field>
        
        The mode can be specified briefly if it should be the same for all forms::
        
            <field type="zope.schema.TextLine"
                    name="secret"
                    form:mode="hidden">
                <title>Secret</title>
                <description>Secret stuff</description>
            </field>
        
        In other words, ``form:mode`` may be either a single mode, or a space-separated
        list of form_interface:mode pairs.
        
        
        Omitting fields
        ~~~~~~~~~~~~~~~
        
        A field can be omitted entirely from all forms, or from some forms,
        using the ``omitted`` and ``no_omit`` diretives. In this example,
        the ``dummy`` field is omitted from all forms, and the ``edit_only``
        field is omitted from all forms except those that provide the
        IEditForm interface::
        
            from z3c.form.interfaces import IEditForm
            from plone.supermodel import model
            from plone.autoform import directives as form
        
            class IMySchema(model.Schema):
                    
                form.omitted('dummy')
                dummy = schema.Text(
                    title=u"Dummy"
                    )
                
                form.omitted('edit_only')
                form.no_omit(IEditForm, 'edit_only')
                edit_only = schema.TextLine(
                    title = u'Only included on edit forms',
                    )
        
        In supermodel XML, this can be specified as::
        
            <field type="zope.schema.TextLine"
                   name="dummy"
                   form:omitted="true">
                <title>Dummy</title>
            </field>
        
            <field type="zope.schema.TextLine"
                   name="edit-only"
                   form:omitted="z3c.form.interfaces.IForm:true z3c.form.interfaces.IEditForm:false">
                <title>Only included on edit form</title>
            </field>
        
        ``form:omitted`` may be either a single boolean value, or a space-separated
        list of form_interface:boolean pairs.
        
        
        Re-ordering fields
        ~~~~~~~~~~~~~~~~~~
        
        A field's position in the form can be influenced using the ``order_before``
        and ``order_after`` directives. In this example, the ``not_last`` field
        is placed before the ``summary`` field even though it is defined afterward::
        
            from plone.supermodel import model
            from plone.autoform import directives as form
        
            class IMySchema(model.Schema):
            
                summary = schema.Text(
                    title=u"Summary",
                    description=u"Summary of the body",
                    readonly=True
                    )
                
                form.order_before(not_last='summary')
                not_last = schema.TextLine(
                    title=u"Not last",
                    )
        
        The value passed to the directive may be either '*' (indicating before or after
        all fields) or the name of another field. Use ``'.fieldname'`` to refer to field
        in the current schema (or a base schema). Use a fully prefixed name (e.g.
        ``'my.package.ISomeSchema'``) to refer to a field in another schema. Use an
        unprefixed name to refer to a field in the default schema for the form.
        
        In supermodel XML, the directives are called ``form:before`` and ``form:after``.
        For example::
        
            <field type="zope.schema.TextLine"
                   name="not_last"
                   form:before="*">
                <title>Not last</title>
            </field>
        
        
        Organizing fields into fieldsets
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        Fields can be grouped into fieldsets, which will be rendered within an HTML
        ``<fieldset>`` tag. In this example the ``footer`` and ``dummy`` fields
        are placed within the ``extra`` fieldset::
        
            from plone.supermodel import model
            from plone.autoform import directives as form
        
            class IMySchema(model.Schema):
            
                model.fieldset('extra', 
                    label=u"Extra info",
                    fields=['footer', 'dummy']
                    )
                
                footer = schema.Text(
                    title=u"Footer text",
                    )
                
                dummy = schema.Text(
                    title=u"Dummy"
                    )
        
        In supermodel XML fieldsets are specified by grouping fields within a
        ``<fieldset>`` tag::
        
          <fieldset name="extra" label="Extra info">
              <field name="footer" type="zope.schema.TextLine">
                  <title>Footer text</title>
              </field>
              <field name="dummy" type="zope.schema.TextLine">
                  <title>Dummy</title>
              </field>
          </fieldset>
        
        
        Changing a field's widget
        ~~~~~~~~~~~~~~~~~~~~~~~~~
        
        Usually, z3c.form picks a widget based on the type of your field.
        You can change the widget using the ``widget`` directive if you want
        users to enter or view data in a different format. For example,
        here we change the widget for the ``human`` field to use yes/no
        radio buttons instead of a checkbox::
        
            from plone.supermodel import model
            from plone.autoform import directives as form
            from z3c.form.browser.radio import RadioFieldWidget
        
            class IMySchema(model.Schema):
                form.widget('human', RadioFieldWidget)
                human = schema.Bool(
                    title = u'Are you human?',
                    )
        
        You can also pass widget parameters to control attributes of the
        widget. For example, here we keep the default widget, but 
        set a CSS class::
        
            from plone.supermodel import model
            from plone.autoform import directives as form
            from z3c.form.browser.radio import RadioWidget
        
            class IMySchema(model.Schema):
                form.widget('human', klass='annoying')
                human = schema.Bool(
                    title = u'Are you human?',
                    )
        
        In supermodel XML the widget is specified using a ``<form:widget>`` tag, which
        can have its own elements specifying parameters::
        
            <field name="human" type="zope.schema.TextLine">
                <title>Are you human?</title>
                <form:widget type="z3c.form.browser.radio.RadioWidget">
                    <klass>annoying</klass>
                </form:widget>
            </field>
        
        Note: In order to be included in the XML representation of a schema,
        widget parameters must be handled by a WidgetExportImportHandler utility.
        There is a default one which handles the attributes defined in
        ``z3c.form.browser.interfaces.IHTMLFormElement``.
        
        Protect a field with a permission
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        By default, fields are included in the form regardless of the user's
        permissions. Fields can be protected using the ``read_permission``
        and ``write_permission`` directives. The read permission is checked when
        the field is in display mode, and the write permission is checked when
        the field is in input mode. The permission should be given with its
        Zope 3-style name (i.e. cmf.ManagePortal rather than 'Manage portal').
        
        In this example, the ``secret`` field is protected by the
        ``cmf.ManagePortal`` permission as both a read and write permission.
        This means that in both display and input modes, the field will
        only be included in the form for users who have that permission::
        
            from plone.supermodel import model
            from plone.autoform import directives as form
        
            class IMySchema(model.Schema):
                form.read_permission(secret='cmf.ManagePortal')
                form.write_permission(secret='cmf.ManagePortal')
                secret = schema.TextLine(
                    title = u'Secret',
                    )
        
        In supermodel XML the directives are ``security:read-permission`` and
        ``security:write-permission``::
        
            <field type="zope.schema.TextLine"
                   name="secret"
                   security:read-permission="cmf.ManagePortal"
                   security:write-permission="cmf.ManagePortal">
                <title>Secret</title>
            </field>
        
        Display Forms
        -------------
        
        Sometimes rather than rendering a form for data entry, you want to display
        stored values based on the same schema. This can be done using a "display form."
        The display form renders each field's widget in "display mode," which means
        that it shows the field value in read-only form rather than as a form input.
        
        To use the display form, create a view that extends ``WidgetsView`` like this:
        
            >>> from plone.autoform.view import WidgetsView
            >>> class MyView(WidgetsView):
            ...     schema = IMySchema
            ...     additionalSchemata = (ISchemaOne, ISchemaTwo,)
            ...
            ...     # ...
        
        To render the form, do not override ``__call__()``. Instead, either implement
        the ``render()`` method, set an ``index`` attribute to a page template or
        other callable, or use the ``template`` attribute of the ``<browser:page />``
        ZCML directive when registering the view.
        
        In the template, you can use the following variables:
        
        * ``view/w`` is a dictionary of all widgets, including those from non-default
          fieldsets (by contrast, the ``widgets`` variable contains only those
          widgets in the default fieldset). The keys are the field names, and the
          values are widget instances. To render a widget (in display mode), you can
          do ``tal:replace="structure view/w/myfield/render" />``.
        * ``view/fieldsets`` is a dictionary of all fieldsets (not including the
          default fieldset, i.e. those widgets not placed into a fieldset). They keys
          are the fieldset names, and the values are the fieldset form instances,
          which in turn have variables like ``widgets`` given a list of all widgets.
        
        
        Behind the scenes: how autoform directives work
        -----------------------------------------------
        
        Zope schema fields do not allow storing arbitrary key-value data associated
        with a particular field. However, arbitrary data can be stored in a
        dictionary on the schema (interface) known as the "tagged values."
        This is where ``plone.autoform`` keeps track of its extra hints,
        whether they are configured via Python directives, an XML model, or some
        other way.
        
        The tagged values are stored under various keys, which are defined
        in the ``plone.autoform.interfaces`` module. They can be set several ways:
        
        * Manually, by using ``setTaggedValue()`` on an interface.
        * By loading the schema from a `plone.supermodel`_ XML file and using the
          ``form:`` prefix
        * By using the directives from ``plone.autoform.directives`` while defining
          a schema in Python.
        
        
        .. _z3c.form: http://pypi.python.org/pypi/z3c.form
        .. _zope.schema: http://pypi.python.org/pypi/zope.schema
        .. _plone.supermodel: http://pypi.python.org/pypi/plone.supermodel
        .. _plone.dexterity: http://pypi.python.org/pypi/plone.dexterity
        
        Changelog
        =========
        
        1.6 (2014-02-22)
        ----------------
        
        - Replace deprecated test assert statements.
          [timo]
        
        - Support anonymous schema (dynamic interfaces with and empty
          __name__ attribute) in autoGroups, opting to use prefix as
          group name for such cases.  This allows subclasses of
          AutoExtensibleForm to implement getPrefix() method as
          a sufficient condition to support an unnamed schema.
          [seanupton]
        
        
        1.5 (2013-08-14)
        ----------------
        
        - Added an option on form to allow display of empty fieldsets.
          [thomasdesvenain]
        
        - fix tests
          [vangheem]
        
        
        1.4 (2013-05-23)
        ----------------
        
        - Enhance the widget directive to allow for specifying widget parameters
          within the schema.
          [davisagli]
        
        - Support passing widget classes in the widget directive in addition to
          IFieldWidgets.
          [davisagli]
        
        - Support serializing widget parameters to XML. This requires implementing
          a IWidgetExportImportHandler utility for the widget type.
          [davisagli]
        
        
        1.3 (2012-08-30)
        ----------------
        
        - Avoid dependency on z3c.form.testing.
          [hannosch]
        
        1.2 (2012-04-15)
        ----------------
        
        - Moved form schema directives here from plone.directives.form, and
          reimplemented them as plone.supermodel directives to avoid depending on
          grok.  Included directives: omitted, no_omit, mode, widget, order_before,
          order_after, read_permission, write_permission
          [davisagli]
        
        1.1 - 2012-02-20
        ----------------
        
        - Added the AutoObjectSubForm class to support form hints for
          object widget subforms.
          [jcbrand]
        
        1.0 - 2011-05-13
        ----------------
        
        - Raise a NotImplementedError instead of NotImplemented as that is not
          an exception but meant for comparisons and is not callable.
          [maurits]
        
        
        1.0b7 - 2011-04-29
        ------------------
        
        - Check to make sure that interfaces and field widgets resolved by the
          supermodel handler are of the correct type.
          [elro]
        
        - Add form:validator support for supermodel.
          [elro]
        
        - Fix issue where permission checks were not applied correctly to schemas being
          added with prefixes.
          [davisagli]
        
        - Add MANIFEST.in.
          [WouterVH]
        
        
        1.0b6 - 2011-02-11
        ------------------
        
        - Fix WidgetsView so that _update and update do not clash.
          [elro]
        
        - Fix view.txt doctest to test actual behaviour, not artifacts from test setup.
          [elro]
        
        
        1.0b5 - 2011-01-11
        ------------------
        
        - Use five.ManageSite permission to check field permissions. We'll avoid
          sniffing for Five/CMFCore permissions.zcml difference between Zope 2.12 and
          2.13. [esteele]
        
        
        1.0b4 - 2010-08-05
        ------------------
        
        - Fixed widget traversal for WidgetsView
          http://groups.google.com/group/dexterity-development/browse_frm/thread/280016ece3ed1462
          [29.08.2010, jbaumann]
        
        - Make field permission checks use the field mode rather than the form mode.
          Fixes http://code.google.com/p/dexterity/issues/detail?id=110
          [optilude]
        
        - Removed some dead code.
          Fixes http://code.google.com/p/dexterity/issues/detail?id=132
          [optilude, shywolf9982]
        
        
        1.0b3 - 2010-04-20
        ------------------
        
        - Properly handle the 'omitted' tagged value when it is set to 'false' for a
          field.
          [davisagli]
        
        - Make it possible to set the 'omitted' and 'mode' settings only for particular
          form interfaces.
          [davisagli]
        
        - Do not omit read-only fields when rendering a form in DISPLAY mode.
          http://code.google.com/p/dexterity/issues/detail?id=118
          [mj]
        
        
        1.0b2 - 2009-07-12
        ------------------
        
        - Changed API methods and arguments to mixedCase to be more consistent with
          the rest of Zope. This is a non-backwards-compatible change. Our profuse
          apologies, but it's now or never. :-/
        
          If you find that you get import errors or unknown keyword arguments in your
          code, please change names from foo_bar too fooBar, e.g. process_fields()
          becomes processFields().
        
          Note in particular that the additional_schemata property is now called
          additionalSchemata. If you have implemented this property yourself, you will
          need to rename it!
          [optilude]
        
        
        1.0b1 - 2009-04-17
        ------------------
        
        - Initial release
        
        
Keywords: plone form z3c.form
Platform: UNKNOWN
Classifier: Framework :: Plone
Classifier: Programming Language :: Python
Classifier: Topic :: Software Development :: Libraries :: Python Modules
