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.

    area
        An area is a part of the screen that a :term:`shell` optionally makes
        available to :term:`tools<tool>` to display :term:`views<view>`.  Each
        area has an identifier and may be asked to display multiple views.  A
        shell will implement a main area that is the focus of the user's
        activity.

    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.

    codec
        A codec encodes an object when writing it to :term:`storage` and/or
        decodes an object when reading it from storage according to a
        :term:`format`.

    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 bound to 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.

    format
        A format defines the structure of an object when it is held in
        :term:`storage`.  When an object is read it is decoded by a
        :term:`codec` according to the format.  When an object is written it is
        encoded by a codec according to the format.  Formats are referenced by
        a 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.  Any methods should be
        provided as stubs and should not include any implementation code.

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

    managed model
        A managed model is a :term:`model` whose lifecycle is managed
        automatically by a :term:`tool`.

    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 for 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 and its user
        interface.  Its functionality is implemented by a set of
        :term:`tools<tool>`.  A shell visualises a set of
        :term:`actions<action>` and :term:`areas<area>`.

    storage
        A persistent repository that can hold objects.  Storage is classified
        as either :term:`streaming storage` or :term:`structured storage`.
        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 with a particular :term:`format` should be allowed to be
        stored in a particular instance of :term:`storage`.

    streaming storage
        Streaming storage is a class of :term:`storage` that stores an object
        using a :term:`codec` 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
        using an implicit :term:`format` specific to the storage.

    tool
        A tool is part of a :term:`shell` that implements a logically related
        sub-set of the functionality of an application.  At its most general
        level it creates and manages a set of related :term:`actions<action>`
        and :term:`views<view>`.  A simple application may consist of a single
        tool.  dip includes default tools for a number of functions common to
        many applications, e.g. model lifecycle management.

    toolkit
        A toolkit is an object that contains factories that create the
        different user interface components (menus, push buttons, file dialogs
        etc.) used by dip.  dip includes the :class:`~dip.toolkits.qt4` that
        contains factories for the standard Qt layouts and widgets.

    view
        A view is a component of a user interface that has been
        :term:`adapted<adapter>` to a sub-class of the :class:`~dip.ui.IView`
        interface.  It has a string identifier and may contain sub-views.  A
        :term:`toolkit` will determine exactly how it is implemented.

    view factory
        A view factory is an instance of a class that, when called, will create
        a :term:`view` that is :term:`adapted<adapter>` to a factory specific
        :term:`interface`.
