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` to display :term:`views`. 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` of a :term:`view` and a :term:`model`. editor An editor is a :term:`view` sub-class that can be :term:`adapted` 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` and :term:`services` when a plugin is enabled. plugin manager A plugin manager is responsible for handling all :term:`plugins`, :term:`extension points` and :term:`services`. 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`. A shell visualises a set of :term:`actions` and :term:`areas`. 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` and :term:`views`. 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 toolkits for Qt v5 and Qt v4. view A view is a component of a user interface that has been :term:`adapted` 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` to a factory specific :term:`interface`.