Glossary
========

.. glossary::

    action
        An action is an abstraction of a user interface component (e.g. a
        push button or an entry in a menu) that can be triggered by the user
        to perform some task.

    adapter
        An adapter is a class that is able to implement an :term:`interface`
        on behalf of another object.  Adapters are instantiated automatically
        when required and are destroyed only when the object they are
        adapting is destroyed.

    attribute path
        An attribute path is a string used access a particular attribute of a
        :term:`model`.  Models may be nested, i.e. contain sub-models and so
        the string may contain ``.`` separated sequence of nested attribute
        names.

    attribute type
        An attribute type defines the type of an attribute of a :term:`model`.
        It is implemented as a descriptor stored as a class attribute of the
        model.

    controller
        A controller manages the interaction between the
        :term:`editors<editor>` of a :term:`view` and a :term:`model`.

    editor
        An editor is a :term:`view` sub-class that can be
        :term:`adapted<adapter>` to the :class:`~dip.ui.IEditor` interface.  It
        is created by an editor factory to handle a particular attribute of a
        particular :term:`model`.

    extension point
        An extension point is a mechanism by which a :term:`plugin` can publish
        and contribute to a list of objects.  Each extension point has a unique
        string identifier.

    interface
        An interface is a special form of :term:`model` that is used to declare
        the API than an object is expected to implement.  It should not include
        any implementation code, although it is normal to include method stubs
        for documentation purposes.

    i/o manager
        An i/o manager manages the available types of :term:`storage`
        available and determines how and where objects may be stored.

    model
        A model is normally a collection of attributes each of which is defined
        as an :term:`attribute type` and is implemented by the
        :class:`~dip.model.Model` class.  In simple cases a model may also be
        implemented as a Python mapping object such as a dictionary.

    plugin
        A plugin is a wrapper, specifically an implementation of the
        :class:`~dip.plugins.IPlugin` interface, around a reusable component
        that ensures it is decoupled from other reusable components.
        Communication between plugins is implemented by
        :term:`extension points<extension point>` and :term:`services<service>`
        when a plugin is enabled.

    plugin manager
        A plugin manager is responsible for handling all
        :term:`plugins<plugin>`, :term:`extension points<extension point>` and
        :term:`services<service>`.

    service
        A service is an object that implements a particular :term:`interface`
        and is published by a :term:`plugin`.  A number of different services
        may be available that implement a particular interface but an
        application will not care which one it actually uses.

    shell
        A shell is an abstraction of an instance of an application's user
        interface, typically a graphical user interface.  At its most general
        level it manages and visualizes the set of :term:`actions<action>` and
        :term:`tools<tool>` that make up an application.

    shell manager
        A shell manager is responsible for the lifecycle of :term:`tools<tool>`
        and the :term:`shell objects<shell object>` they operate on.

    shell object
        A shell object is an object whose lifecycle is managed by a
        :term:`shell manager`.

    storage
        A persistent repository that can hold objects.  Storage is classified
        as either :term:`streaming storage` or :term:`structured storage`.
        Storage may specify that it can only store objects of a particular
        type.  Each stored object has a unique :term:`storage location`.

    storage location
        A storage location is the unique address of an object in
        :term:`storage`.  The nature of the location will depend on the
        storage.  For example for a filesystem it may be the absolute pathname
        of a file.  A location might be implicit in that its value may depend
        on the value of the object.  In which case a user will not be able to
        change the location.

    storage policy
        A storage policy is called by an :term:`i/o manager` to determine if
        an object should be allowed to be stored in a particular type of
        :term:`storage`.

    streaming storage
        Streaming storage is a class of :term:`storage` that stores an object
        as an encoded stream of bytes.  A filesystem is the most common
        example of streaming storage.

    structured storage
        Structured storage is a class of :term:`storage` that stores an object
        as some implicit structure specific to the storage.

    tool
        A tool is a sub-set of an application that allows the user to perform
        a set of logically related actions on a :term:`shell object`.  A simple
        application may consist of a single tool.  A tool is implicitly
        managed, i.e. it relies on a :term:`shell manager` to manage the
        lifecycle of the shell object it is operating on.
        :term:`Unmanaged tools<unmanaged tool>` explicitly manage the objects
        they operate on.

    toolkit
        A toolkit is an object that contains factories that create the
        different GUI elements (menus, push buttons, file dialogs etc.) used
        by dip.  dip includes the :class:`~dip.ui.toolkits.qt.QtToolkit`
        that contains factories for the standard Qt widgets.

    unmanaged tool
        An unmanaged tool is a :term:`tool` that manages the lifecycle of the
        object it is operating on itself.

    view
        A view is a :class:`~PyQt4.QtGui.QLayout` or a
        :class:`~PyQt4.QtGui.QWidget` instance that can be
        :term:`adapted<adapter>` to the :class:`~dip.ui.IView` interface.  It
        is created by a view factory which itself can contain a number of
        sub-view factories.
