Metadata-Version: 1.0
Name: dolmen.app.layout
Version: 1.0b2
Summary: Layout and page models for Dolmen applications
Home-page: http://gitweb.dolmen-project.org/
Author: Souheil Chelfouh
Author-email: trollfot@gmail.com
License: GPL
Description: =================
        dolmen.app.layout
        =================
        
        `dolmen.app.layout` provides ready-to-use components to get a fully
        functional and extensively pluggable User Interface for a Dolmen
        application (see `dolmen.app.site`).
        
        
        About Dolmen
        ============
        
        Dolmen is an application development framework based on Grok and ZTK
        which also provides a CMS (Content Management System) out of the
        box. Dolmen is being made with four main objectives in mind: easily
        pluggable, rock solid and fast content type development, readability
        and speed.
        
        
        Getting started
        ===============
        
        We import all the needed dependencies of the tests::
        
          >>> from dolmen import content
          >>> from grokcore.component import testing
          >>> from zope.site.hooks import getSite
          >>> from zope.component import getMultiAdapter 
          >>> from zope.publisher.browser import TestRequest
           
        We import everything needed for the API verification::
        
          >>> from zope.interface import verify
          >>> from dolmen.app.layout import interfaces as API
         
        We define and intanciate a Context object and a request for our tests
        to come::
        
          >>> class Mammoth(content.Content):
          ...    content.name(u'Furry Mammoth')
        
          >>> testing.grok_component('mammoth', Mammoth)
          True
        
          >>> root = getSite()
          >>> root['manfred'] = Mammoth()
          >>> manfred = root['manfred']
        
          >>> request = TestRequest()
        
        
        Global interface
        ================
          
          >>> from dolmen.app.layout import master
        
          >>> API.IGlobalUI.extends(API.IContentProviders)
          True
        
          >>> API.IGlobalUI.providedBy(master)
          True
          >>> verify.verifyObject(API.IGlobalUI, master)
          True
        
        
        Content providers
        -----------------
         
        Description
        ~~~~~~~~~~~
        
          >>> for name, attr in API.IContentProviders.namesAndDescriptions():
          ...   print "%s: %s" % (name, attr.getDoc())
          Footer: Viewlet manager for the bottom part of the body.
          AboveBody: Viewlet manager located above the main content.
          BelowBody: Viewlet manager located below the main content.
          Header: Viewlet manager involved in rendering the HTML head.
          Top: Viewlet manager for the top part of the body.
          Resources: Viewlet manager including resources.
        
        
        Layout
        ------
        
        Description
        ~~~~~~~~~~~
        
          >>> interfaceDescription(API.IGlobalUI)
          Master: Base layout using all the `IContentProviders` components to build a coherent yet overridable rendering.
        
        
        Contextual UI
        =============
        
          >>> from dolmen.app.layout import viewlets
        
          >>> API.IContextualUI.providedBy(viewlets)
          True
          >>> verify.verifyObject(API.IContextualUI, viewlets)
          True
        
        Description
        -----------
        
          >>> interfaceDescription(API.IContextualUI)
          ContextualActions: Viewlet rendering contextual actions.
          FlashMessages: Viewlet displaying site-wide messages.
        
        
        View components
        ===============
        
          >>> from dolmen.app.layout import models
        
        Models
        ------
        
        Models are base classes to be used in your own
        classes. `dolmen.app.layout` provides a collections of ready-to-use
        models::
        
          >>> API.IModels.providedBy(models)
          True
          >>> verify.verifyObject(API.IModels, models)
          True
        
        Description
        ~~~~~~~~~~~
        
          >>> interfaceDescription(API.IModels)
          Index: Page showing as default view on an object.
          Form: Generic page form.
          Page: Page embedded in a layout.
        
        Default views
        -------------
        
        `dolmen.app.layout` registers some views, out-of-the-box, to allow you
        to interact with your `dolmen.content` objects and your application::
        
          >>> API.IBaseViews.providedBy(models)
          True
          >>> verify.verifyObject(API.IBaseViews, models)
          True
        
        Description
        ~~~~~~~~~~~
        
          >>> interfaceDescription(API.IBaseViews)
          Edit: Default edit form.
          Add: Default add form.
          DefaultView: Display form used as index.
          Delete: Default delete form.
        
        Query
        ~~~~~
        
        We can now test to see if our default views are retrieved::
        
          >>> view = getMultiAdapter((manfred, request), name="index")
          >>> view
          <dolmen.app.layout.models.DefaultView object at ...>
        
          >>> edit = getMultiAdapter((manfred, request), name="edit")
          >>> edit
          <dolmen.app.layout.models.Edit object at ...>
        
        The add form is a bit different, as it relies on an adding view (see
        `dolmen.forms.crud` and `dolmen.content` for more information)::
        
          >>> from dolmen.forms.crud import Adder
        
          >>> adding = Adder(root, request)
          >>> adding
          <dolmen.forms.crud.addview.Adder object at ...>
        
          >>> adding.traverse("dolmen.app.layout.Mammoth", None)
          <dolmen.app.layout.models.Add object at ...>
        
        
        Skins
        =====
        
        `dolmen.app.layout` provides a browser layer and a skin, to serve as a
        base component for your own skins::
        
          >>> from dolmen.app.layout import skin
        
          >>> API.ISkin.providedBy(skin)
          True
          >>> verify.verifyObject(API.ISkin, skin)
          True
        
        Description
        -----------
        
          >>> interfaceDescription(API.ISkin)
          IBaseSkin: Skin providing the IBaseLayer. Can be applied directly or inherited.
          IBaseLayer: Layer used to register all the Dolmen centric view components.
          Resource: Viewlet component used to include resources
        
        
        Menus
        =====
        
          >>> from dolmen.app.layout import menus
        
          >>> API.IMenus.providedBy(menus)
          True
          >>> verify.verifyObject(API.IMenus, menus)
          True
        
        Description
        -----------
        
          >>> interfaceDescription(API.IMenus)
          ContextualMenu: Menu defining contextual actions.
          MenuViewlet: Generic viewlet rendering a `IBrowserMenu`.
        
        Contextual menu
        ---------------
        
          >>> manager = master.Top(manfred, request, view)
          >>> manager
          <dolmen.app.layout.master.Top object at ...>
        
          >>> manager.update()
          >>> print manager.render()
          <dl id="contextual-actions" class="menu">
            <dt>Contextual actions</dt>
            <dd>
              <ul>
                <li class="selected entry">
          	  <a title="View">View</a>
                </li>
                <li class="entry">
            	  <a href="http://127.0.0.1/manfred/edit" title="Edit">Edit</a>
                </li>
                <li class="entry">
            	  <a href="http://127.0.0.1/manfred/delete" title="Delete">Delete</a>
                </li>
              </ul>
            </dd>
          </dl>
        
        
        Credits
        =======
        
        All Dolmen packages are sponsorised by NPAI (http://www.npai.fr)
        
        
        Changelog
        =========
        
        1.0b2 (2011-02-01)
        ------------------
        
        * Updated versions dependencies to remove the use of
          ``megrok.resource`` in favor of ``fanstatic``.
        
        
        1.0b1 (2010-11-16)
        ------------------
        
        * The ContextualMenu viewlet now computes the URL using the 'url'
          attribute of the entries, as it should be.
        
        
        1.0a2 (2010-11-05)
        ------------------
        
        * Dependencies have been slimmed down : ``dolmen.app.layout`` now longer
          provides coverage for the ``megrok.z3ctable`` and ``zeam.form.composed``
          packages. We now rely on the grokcore packages and no longer on the
          ``grok`` package itself.
        
        * Tests no longer use ``zope.testing``.
        
        
        1.0a1 (2010-06-03)
        ------------------
        
        * The flash messages are now retrieved thanks to `grokcore.message`.
        
        * Tests have been corrected and simplified.
        
        * Using now `zeam.form` instead of `z3c.form`.
        
        * Using now `dolmen.menu` instead of `megrok.menu`.
        
        * `dolmen.app.layout` now required python2.6 to work. This is due to
          the use of class decorators.
        
        
        0.5.1 (2010-02-26)
        ------------------
        
        * Corrected the success message getter for the `Delete` form. It used
          to fetch the property object and try to persist it. Now, it gets its
          value as it should.
        
        
        0.5.0 (2010-02-25)
        ------------------
        
        * Using now the latest ``megrok.layout``. This removes the need for the
          `ApplicationAwareView` mixin. This version of ``dolmen.app.layout`` will
          only work with `Grok >= 1.1rc1`.
        
        
        0.4.0 (2010-02-17)
        ------------------
        
        * INotFound errors are not located in the `index.html` view. This
          allows to use a layout transparently. The __parent__ is set to the
          `ob` attribute of the INotFound object.
        
        * The contextual menu is no longer restricted to `IBaseContent`
          objects. It is now registered for `Interface`.
        
        * The dependencies have been greatly reduced by the removal of all the
          `zope.app` packages.
        
        
        0.3.1 (2010-01-21)
        ------------------
        
        * Bug fix: the success message of a Delete form is a property and
          can't be called directly through the class. We need to use fget.
        
        
        0.3 (2009-12-26)
        ----------------
        
        * The layout now provides and uses a way to include resources, using
          megrok.resourceviewlet. Two components have been added for that:
          `ResourcesManager` and `Resource`, respectively a viewletmanager and
          a viewlet base class.
        
        * The imports has been modified to avoid using any zope.app package.
        
        
        0.2.2 (2009-11-03)
        ------------------
        
        * Now the configure.zcml includes the `megrok.z3ctable` meta.zcml.
        
        * Updated dependencies in setup.py
        
        
        0.2.1 (2009-11-02)
        ------------------
        
        * Corrected flash messages and redirection in the delete form.
        
        
        0.2 (2009-11-02)
        ----------------
        
        * Added Delete form to complete the CRUD actions.
        
        
        0.1 (2009-11-02)
        ----------------
        
        * Initial release
        
Keywords: Grok Zope3 CMS Dolmen
Platform: Any
Classifier: Environment :: Web Environment
Classifier: Framework :: Zope3
Classifier: License :: OSI Approved :: GNU General Public License (GPL)
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
