Metadata-Version: 1.0
Name: zeam.form.ztk
Version: 1.2
Summary: Zope Toolkit support for zeam.form
Home-page: http://pypi.python.org/pypi/zeam.form.ztk
Author: Sylvain Viollon
Author-email: thefunny@gmail.com
License: BSD
Description: =============
        zeam.form.ztk
        =============
        
        ``zeam.form.ztk`` help you to integrate `zeam.form.base`_ with the
        Zope Tool Kit. It provides:
        
        - Form fields generation out of zope.schema fields, and zope.schema
          fields listed in a Zope interface,
        
        - Widgets for those fields,
        
        - Default action to Add, Edit a content, Cancel a current action by
          returning on the default view of a content.
        
        Like `zeam.form.base`_ the focus is to have an API usable by the
        developer, not a support of theorical use-cases that you don't need.
        
        .. contents::
        
        Example
        =======
        
        Let's create a form to edit a content. Here we have an interface for
        our content::
        
          from zope import schema, interface
        
          class IClan(interface.Interface):
             pass
        
          class IPerson(interface.Interface):
        
             first_name = schema.TextLine(title=u"First Name")
             last_name = schema.TextLine(title=u"Last Name")
             age = schema.Int(title=u"Age", required=False)
             single = schema.Bool(title=u"Is single ?", default=True)
        
        We assume that a Person is in a Clan. We can implement a Person::
        
          from persistence import Persistent
        
          class Person(Persistent):
              interface.implements(IPerson)
        
              first_name = None
              last_name = None
              age = None
              single = True
        
        Add form
        --------
        
        You can add a new Person in a clan like this::
        
          import zeam.form.ztk as form
        
          class Add(form.Form):
        
              form.context(IClan)
        
              label = u"New person"
              fields = form.Fields(IPerson)
              actions =  form.Actions(
                   form.AddAction("Add", factory=Person),
                   form.CancelAction("Cancel"))
              actions['add'].fieldName = 'last_name'
        
        
        Edit form
        ---------
        
        You can edit a Person like this::
        
          class Edit(form.Form):
        
              form.context(IPerson)
        
              label = u"Change person details"
              fields = form.Fields(IPerson)
              actions =  form.Actions(
                   form.EditAction("Update"),
                   form.CancelAction("Cancel"))
        
              ignoreContent = False
        
        
        API
        ===
        
        All the API of ``zeam.form.base`` is exported as well.
        
        Actions
        -------
        
        ``AddAction``
          Action which take an extra parameter, factory, to create an object
          stored on the content object. The created object is added with the
          help of ``INameChooser`` to get its identifier. The option
          ``fieldName`` will be used to lookup a value in the form data to
          give as potential identifier to ``INameChooser``. Afterwards the
          created object is edited (like EditAction does) with the form data.
        
        ``EditAction``
          Action which use the form data to change values on the content
          object, designated by the form fields, after validation of the form
          submission.
        
        ``CancelAction``
          Simple action which return on default view of the content without
          validating the form submission.
        
        
        Fields
        ------
        
        Currently supported fields:
        
        - Date, Datetime: generate a text line input and parse/display the
          date using the locale,
        
        - TextLine, Text, Boolean, URI, and numbers (Int, Float ...),
        
        - Password,
        
        - Choice: generate a select or a radio boxes (widget mode ``radio``),
        
        - Object,
        
        - Collections: List, Set, Tuple in input and display mode:
        
          - Collection of choices: generate a widget with a list of checkboxes,
        
          - Collection of objects: generate a table to edit multiple objects,
        
          - Other collection: generate a widget with generic add an remove actions.
        
        
        For more documentation, please report to the doctests included in the code.
        
        
        .. _zeam.form.base: http://pypi.python.org/pypi/zeam.form.base
        
        Changelog
        =========
        
        1.2 (2011/11/08)
        ----------------
        
        * Improve error reporting in collection widgets. Thanks to Novareto
          for the sponsorship.
        
        * Add an validation option in collection widgets while adding and
          removing values from it. Thanks to Novareto for the sponsorship.
        
        * Improve Javascript for collection widgets. Add an extra with
          fanstatic to automatically require required files.
        
        * If a collection widget is required, it will by default display one
          empty item in the collection when it is empty. That prevent an extra
          click to add it.
        
        * Various fixes in ``InvariantsValidator``.
        
        * ``SchemaWidgetExtractor`` and ``SchemaField`` now catch Invalid
          exceptions.
        
        * Add support for the HTML 5 attribute required in every template. Use
          the attribute novalidate on the form tag to disable it.
        
        * Add a display widget for object and uri fields.
        
        * Add an option ``valueLength`` to the date widgets. Any Zope
          formatter size can be use (``short``, ``medium`` ...).
        
        1.0 (2010/10/19)
        ----------------
        
        * Add a ``multiselect`` widget for multiple choices.
        
        * Add a ``readonly`` widget.
        
        * Add a ``display`` widget for booleans and collections.
        
        * Add HTML5 widgets for URIs.
        
        * Schema field can be adapted now, even if they don't have a interface
          (if they provide an attribute __name__).
        
        * Add more tests, fix issues in collection widgets, and invariant
          validator.
        
        * Translations are all located in ``zeam.form.base``.
        
        * Update to use the last version of ``zeam.form.base``.
        
        1.0rc2 (2010/07/16)
        -------------------
        
        * Add ``radio`` widget for choices.
        
        * Add a display widgets for multiple choices.
        
        * All fields have the ``field`` CSS class.
        
        * Multiple choices widgets now properly respect the value of a vocabulary term.
        
        1.0rc1 (2010/07/05)
        -------------------
        
        * Updated entry points registrations to be compatible with latest
          ``zeam.form.base``.
        
        1.0b3 (2010/06/22)
        ------------------
        
        * Field wrapper registration is now made thanks to an entry point.
        * Added invariants validation.
        * Added A generic adaptive datamanager that can adapt the form content to
          one or several interfaces.
        
        1.0b2 (2010/05/13)
        ------------------
        
        * Improve widget initialization, and testing layer support.
        * Fix choice widgets when they are used with vocabulary factories.
        
        1.0b1 (2010/05/03)
        ------------------
        
        * Initial release, with not all the widgets.
        
Keywords: zeam form zope schema edit content
Platform: UNKNOWN
Classifier: Framework :: Zope3
Classifier: Programming Language :: Python
Classifier: Programming Language :: Zope
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Libraries :: Python Modules
