/*! \page ex1 A simple plugin
 *
 * In this tutorial we are going to build our own OpenFlipper plugin step by step. The goal of this
 * tutorial is to build a simple plugin that is loaded by OpenFlipper at launch.
 *
 * We start by creating the plugin directory in OpenFlipper's root directory,
 * naming it e.g. \c Plugin-SimplePlugin.
 * The interface definition should contain the following header includes:
 * 
 * \dontinclude example/simplePlugin.hh
 * \skipline #include
 * \until Types.hh>
 *
 * As we know the plugin class has to be derived from at least \c BaseInterface,
 * the class definition will look like:
 *
 * \dontinclude example/simplePlugin.hh
 * \skipline class
 *
 * (Since we implement a Qt-class, our base object is QObject which provides
 * some basic functionality and type definitions.)
 * We then use the macros \c Q_OBJECT and \c Q_INTERFACES in order to make accessible the signals and
 * slots which have to be overridden later on. See BaseInterface documentation for signals and slots
 * that can be overriden.
 *
 * \dontinclude example/simplePlugin.hh
 * \skipline Q_OBJECT
 * \skipline Q_INTERFACES
 *
 * For now, the only thing we override from our base class is \c name() and \c description() which
 * each returns the name and description of our plugin, respectively. The override of these two
 * functions is mandatory, all other slots/signals are optional.
 * Each of the functions returns a QString (see Qt documentation for information on Qt types).
 *
 * \dontinclude example/simplePlugin.hh
 * \skipline QString name(
 * \skipline QString description(
 *
 * If you made it to this point, don't give up, we're almost there! Looks like this is it for
 * the interface definition. We're now considering our implementation which consists of only a few lines.
 * (Since we don't want to implement any functionality at this point).
 *
 * The implementation only contains the macro
 *
 * \dontinclude example/simplePlugin.cc
 * \skipline Q_EXPORT
 *
 * which exports the plugin class \c SimplePlugin with the name \c simplePlugin (note that our class
 * name is with a capital s whereas the export name is lower case). An important constraint is
 * that the export name has to be unique (in case there exist multiple plugins).
 *
 * The complete source code of the plugin looks like this:
 *
 * simplePlugin.hh
 * \include example/simplePlugin.hh
 *
 * simplePlugin.cc
 * \include example/simplePlugin.cc
 *
 *
 * \section ex1c How to build the plugin with CMake
 * 
 * The only thing that's still left to be created is our cmake project file
 * that is used to generate the Makefiles for the plugin.
 * This step is very easy, so let's start. In your plugin's root directory
 * create a CMakeLists.txt file.
 *
 * Our first line includes OpenFlipper's predefined cmake plugin functions. This allows us to simply call the
 * \c openflipper_plugin() macro in order to build our code as a plugin. Our project file then looks like this:
 *
 * CMakeLists.txt
 * \include example/CMakeLists.txt
 *
 * Note that you have several options that can be passed to the openflipper_plugin() function,
 * see \ref cmake_plugin for details. For our example project we just have to
 * leave this line as it is.
 *
 * Now, when building OpenFlipper with cmake, your plugin should be found and built automatically.
 *
 * To test if our plugin has been successfully loaded, we launch OpenFlipper and select \c Plugins->Unload \c Plugin.
 * If our plugin \c SimplePlugin is listed, everything is fine. If it's not listed, read OpenFlippers
 * log to see what went wrong.
 *
 * See \ref dataFlow for further information on interface function calls.
 */
