/** \page interfaces Plugin Interfaces

\section pluginInterfacesIntro Introduction

OpenFlipper provides a flexible plugin interface. Plugins can implement various interfaces.\n

Each interface provides special signals/slots or functions to communicate with the core or
to react on special events. The most important interface is the BaseInterface. This Interface
provides the core functionality for the plugin. E.g. loading the plugin, specifying its name
and basic communication regarding object changes or view updates ( See BaseInterface for further details).\n

Additional functionality is provided by the other interfaces. For user interaction one typically uses the
MouseInterface or KeyInterface which will provide events based on mouse or keyboard interaction.\n

The user interface of OpenFlipper can also be used by plugins. The MenubarInterface provides functions to
add additional icons to the menubar while the ToolboxInterface can add widgets to the toolbox on
the right of the OpenFlipper screen.

\section pluginInterfacesUsage Usage of plugin interfaces

To use functions from one of the interfaces you have to do the following steps:
<ul>
<li> Include the interface header file in your plugins header file
<li> derive your plugin from the Interface class defined in the interface header file
<li> add Q_INTERFACES( InterfaceName ) macro to your plugin class containing only the name of the interface to be used
<li> Add the signature of the signals you want to use to the signals of your class definition.
<li> Add the signature of a slot you want to implement to the \b private \b slots of your class definition.
</ul>
It is not necessary to implement all signals or slots from one of the interfaces (Except some functions from BaseInterface).
The core application will only use the slots you define in the plugins header file and ignore all other functions.\n

If you recognize that an interface function of your plugin is not called, check if it is defined correctly in your plugin
class and the signature is the same as in the interface.\n

\section pluginInterfacesBaseInterface OpenFlipper Base Interface

\subpage baseInterfacePage

All plugins in OpenFlipper have to implement some basic functions from BaseInterface. They are used to integrate and manage
the plugins by the core application. See \ref baseInterfacePage for details.


\section  pluginInterfacesGroups Interfaces
The following groups of Interfaces are available:

\subpage pluginInterfacesUIOverview

\subpage pluginInterfacesDataHandling

\subpage pluginInterfacesInputDevices

\subpage pluginInterfacesRendering

\subpage pluginInterfacesOtherInterfaces



\section todoInterfaces Interfaces TODO for documentation:

\subsection TexturePlugin Texture Interface
\image html TextureInterface.png
Allows your plugin to provide a texture. ( TextureInterface )

\subsection ViewPlugin View Interface
\image html ViewInterface.png
This interface is used to add additional view widgets ( ViewInterface ).

\subsection INIPlugin Use Inifiles to store information
\image html INIInterface.png
Receive an event if an ini file is opened by the application. ( INIInterface )\n

*/


/** \page pluginInterfacesUIOverview User Interface control

This page gives an overview over the available interfaces which control OpenFlippers User interface.

\subpage contextMenuInterfacePage
\image html ContextMenuInterface.png
Add context menu entries in your plugin. ( \ref contextMenuInterfacePage )
\n

\subpage loggingInterfacePage
\image html LoggingInterface.png
This is an Interface for Logging to the included log widget. You can log to different levels
(LOGOUT,LOGWARN,LOGERR,LOGINFO) ( \ref loggingInterfacePage ).
\n

\subpage menuInterfacePage
\image html MenuInterface.png
Provides a function to create entries in the menubar ( \ref menuInterfacePage ).
\n

\subpage optionsInterfacePage
\image html OptionsInterface.png
This Interface is used by plugins which will provide their own options by
integrating an options widget into OpenFlipper's options window ( \ref optionsInterfacePage ).
\n

\subpage pickingInterfacePage
\n
\image html PickingInterface.png
\n
Handle pick modes in your plugin ( \ref pickingInterfacePage )
\n

\subpage statusbarInterfacePage
\image html StatusbarInterface.png
This interface is used to display messages in the status bar or adding widgets to it ( \ref statusbarInterfacePage ).
\n

\subpage toolboxInterfacePage
\image html ToolboxInterface.png
Provides functions to create a separate widget in the toolbox on the right ( \ref toolboxInterfacePage ).
\n

\subpage toolbarInterfacePage
\image html ToolbarInterface.png
Provides a function to add toolbar buttons. ( \ref toolbarInterfacePage  )
\n


\subpage viewModeInterfacePage
\image html ViewModeInterface.png
Specify own view modes setting which toolboxes/toolbars/context menus will be visible( \ref viewModeInterfacePage )

\subpage AboutInfoInterfacePage
\image html AboutInfoInterface.png
Add own information to OpenFlippers abouot dialog
*/

/** \page pluginInterfacesDataHandling Object and Data Handling
This page shows interfaces for controlling and adding Objects.


\subpage fileInterfacePage
\image html FileInterface.png
Provides an interface to read and write file types. All load/save plugins need to implement this interface ( \ref fileInterfacePage )

\subpage loadSaveInterfacePage
\image html loadSaveInterface.png
Provides functions to control loading/saving of files and generate new objects. Additionally
this interface informs plugins, when objects get added or removed( \ref loadSaveInterfacePage ).

\subpage metaDataInterfacePage
\image html metaDataInterface.png
This interface provides functions for serializing and deserializing MetaData which is stored in screenshots or other files( \ref metaDataInterfacePage ).

\subpage selectionInterfacePage
\image html SelectionInterface.png
This interface provides functions which control OpenFlippers selection system. Selection plugins
can use this interface to react on selection events and add selections for different primitives ( \ref selectionInterfacePage ).


\subpage typeInterfacePage
\image html TypeInterface.png
Allows plugins to specify custom data types and makes them available
to other plugins ( \ref typeInterfacePage ).

\subpage informationInterfacePage
\image html informationInterface.png
Allows plugins to provide information on objects of a
specific data type ( \ref informationInterfacePage ).

\subpage backupInterfacePage
\image html BackupInterface.png
Use this interface to backup data ( \ref backupInterfacePage )

*/


/** \page pluginInterfacesInputDevices Input Devices
This page shows interfaces which could be used to get data from input devices.


\subpage mouseInterfacePage
\n
\image html mouseInterface.png
\n
This interface is used to deliver mouse events to a plugin ( \ref mouseInterfacePage ).\n
\n

\subpage pickingInterfacePage
\n
\image html PickingInterface.png
\n
Handle pick modes in your plugin ( \ref pickingInterfacePage )
\n

\subpage keyInterfacePage
\n
\image html keyInterface.png
\n
You have to implement this interface if you want to get key events in your plugin ( \ref keyInterfacePage ).\n
\n

*/

/** \page pluginInterfacesOtherInterfaces Other Interfaces
This page shows interfaces for other operations.

\subpage RPCInterfacePage
\n
\image html RPCInterface.png
\n
Interface to call functions across plugins ( \ref RPCInterfacePage  )
\n

\subpage pythonInterfacePage
\n
\image html ScriptInterface.png
\n
For plugins which provide python scriptable functions ( \ref pythonInterfacePage  )
\n

\subpage scriptInterfacePage
\n
\image html ScriptInterface.png
\n
For plugins which provide scriptable functions ( \ref scriptInterfacePage  )
\n


\subpage pluginConnectionInterfacePage
\n
\image html PluginConnectionInterface.png
\n
Enables the developer to connect signals and slots across plugins. ( \ref pluginConnectionInterfacePage  )
\n

\subpage processInterfacePage
\n
\image html ProcessInterface.png
\n
The ProcessInterface can be used to start arbitrary functions within threads. ( \ref processInterfacePage  )
\n

\subpage securityInterfacePage
\n
\image html SecurityInterface.png
\n
The security Interface can be used to add a license management to your plugin. When it is used,
plugins will only start, if a valid license is available. The license is bound to a machine
(Processor,network,...) and expires after a specified date. ( \ref securityInterfacePage  )
\n

*/

/** \page pluginInterfacesRendering Rendering Interface
This page shows interfaces which could be used to modify OpenFlippers rendering system


\subpage renderInterfacePage
\n
\image html RenderInterface.png
\n
The RenderInterface can be used to replace OpenFlippers default renderer. Therefore special rendering
capabilities can be added as a plugin.( \ref renderInterfacePage  )
\n

\subpage postProcessorInterfacePage
\n
\image html PostProcessorInterface.png
\n
The PostProcessorInterface can be used to add a post processing step to OpenFlipper. After an image is
rendered, it is passed to the post processor which can add additional image processing steps
like edge detection.( \ref postProcessorInterfacePage  )
\n

*/







