addInInterface.h

/* ********************************************************************
itom software
URL: http://www.uni-stuttgart.de/ito
Copyright (C) 2016, Institut fuer Technische Optik (ITO),
Universitaet Stuttgart, Germany

This file is part of itom and its software development toolkit (SDK).

itom is free software; you can redistribute it and/or modify it
under the terms of the GNU Library General Public Licence as published by
the Free Software Foundation; either version 2 of the Licence, or (at
your option) any later version.

In addition, as a special exception, the Institut fuer Technische
Optik (ITO) gives you certain additional rights.
These rights are described in the ITO LGPL Exception version 1.0,
which can be found in the file LGPL_EXCEPTION.txt in this package.

itom is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
General Public Licence for more details.

You should have received a copy of the GNU Library General Public License
along with itom. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************** */

#ifndef ADDININTERFACE_H
#define ADDININTERFACE_H

#include "commonGlobal.h"

#include "apiFunctionsInc.h"
#include "apiFunctionsGraphInc.h"

#include "sharedStructuresQt.h"
#include "sharedStructures.h"

#include <qlist.h>
#include <qmap.h>
#include <qpair.h>
#include <qset.h>
#include <qthread.h>
#include <qsharedpointer.h>
#include <qmutex.h>
#include <qapplication.h>

#if QT_VERSION < 0x050000
#include <qpluginloader.h>
#include <qdockwidget.h>
#else
#include <QtCore/qpluginloader.h>
#include <QtWidgets/qdockwidget.h>
#endif

//plugins define VISUAL_LEAK_DETECTOR_CMAKE in their CMake configuration file
#if defined _DEBUG  && defined(_MSC_VER) && defined(VISUAL_LEAK_DETECTOR_CMAKE)
#ifndef NOMINAX
#define NOMINMAX //instead min, max is defined as macro in winDef.h, included by vld.h
#include "vld.h"
#undef NOMINMAX
#else
#include "vld.h"
#endif
#endif

#if !defined(Q_MOC_RUN) || defined(ITOMCOMMONQT_MOC) //only moc this file in itomCommonQtLib but not in other libraries or executables linking against this itomCommonQtLib

//write this macro right after Q_INTERFACE(...) in your interface class definition
#define PLUGIN_ITOM_API \
            protected: \
                void importItomApi(void** apiPtr) \
                                {ito::ITOM_API_FUNCS = apiPtr;} \
                void importItomApiGraph(void** apiPtr) \
                                { ito::ITOM_API_FUNCS_GRAPH = apiPtr;} \
            public: \
                //.


#define NEW_PLUGININSTANCE(PluginClass) \
    PluginClass* newInst = new PluginClass(); \
    newInst->setBasePlugin(this); \
    *addInInst = qobject_cast<ito::AddInBase*>(newInst); \
    m_InstList.append(*addInInst);


#define REMOVE_PLUGININSTANCE(PluginClass) \
   if (*addInInst) \
      { \
      delete qobject_cast<PluginClass*>(*addInInst); \
      m_InstList.removeOne(*addInInst); \
      } 


#define REGISTER_FILTERS_AND_WIDGETS \
    foreach(ito::AddInAlgo::FilterDef *f, newInst->m_filterList) \
        { \
        f->m_pBasePlugin = this; \
        } \
    foreach(ito::AddInAlgo::AlgoWidgetDef *w, newInst->m_algoWidgetList) \
        { \
        w->m_pBasePlugin = this; \
        }


namespace ito
{
    //----------------------------------------------------------------------------------------------------------------------------------

    enum tPluginType {
        typeDataIO = 0x1,     
        typeActuator = 0x2,     
        typeAlgo = 0x4,     
        typeGrabber = 0x80,    
        typeADDA = 0x100,   
        typeRawIO = 0x200   
    };


    enum tActuatorStatus {
        //moving flags
        actuatorUnknown = 0x0001, 
        actuatorInterrupted = 0x0002, 
        actuatorMoving = 0x0004, 
        actuatorAtTarget = 0x0008, 
        actuatorTimeout = 0x0010, 
        //switches
        actuatorEndSwitch = 0x0100, 
        actuatorLeftEndSwitch = 0x0200, 
        actuatorRightEndSwitch = 0x0400, 
        actuatorRefSwitch = 0x0800, 
        actuatorLeftRefSwitch = 0x1000, 
        actuatorRightRefSwitch = 0x2000, 
        //status flags
        actuatorAvailable = 0x4000, 
        actuatorEnabled = 0x8000, 
        actMovingMask = actuatorUnknown | actuatorInterrupted | actuatorMoving | actuatorAtTarget | actuatorTimeout, 
        actEndSwitchMask = actuatorEndSwitch | actuatorLeftEndSwitch | actuatorRightEndSwitch, 
        actRefSwitchMask = actuatorRefSwitch | actuatorLeftRefSwitch | actuatorRightRefSwitch, 
        actSwitchesMask = actEndSwitchMask | actRefSwitchMask,                                
        actStatusMask = actuatorAvailable | actuatorEnabled                                 
    };

    enum tAutoLoadPolicy {
        autoLoadAlways = 0x1, 
        autoLoadNever = 0x2, 
        autoLoadKeywordDefined = 0x4  
    };

    enum tAutoSavePolicy {
        autoSaveAlways = 0x1, 
        autoSaveNever = 0x2  
    };

    struct ExecFuncParams{
        ExecFuncParams() : infoString("") {}
        QVector<Param> paramsMand; 
        QVector<Param> paramsOpt;  
        QVector<Param> paramsOut;  
        QString infoString;
    };

    struct FilterParams {
        QVector<Param> paramsMand;
        QVector<Param> paramsOpt;
        QVector<Param> paramsOut;
    };

    class AddInBase;        
    class DataObject;
    class AddInBasePrivate; 

    //----------------------------------------------------------------------------------------------------------------------------------
    class ITOMCOMMONQT_EXPORT AddInInterfaceBase : public QObject
    {
        Q_OBJECT

    private:
        virtual ito::RetVal closeThisInst(ito::AddInBase **addInInst) = 0;

    protected:
        int m_type;                                     
        int m_version;                                  
        QString m_filename;                             
        int m_maxItomVer;                               
        int m_minItomVer;                               
        QString m_author;                                
        QString m_description;                          
        QString m_detaildescription;                    
        QString m_license;                              
        QString m_aboutThis;
        QList<ito::AddInBase *> m_InstList;             
        QVector<ito::Param> m_initParamsMand;          
        QVector<ito::Param> m_initParamsOpt;           
        //bool m_enableAutoLoad;                          //* Varialbe to enable autoload for plugin. Standard value is false. Must be overwritten in AddInConstructor  */
        tAutoLoadPolicy m_autoLoadPolicy;               
        tAutoSavePolicy m_autoSavePolicy;               
        bool m_callInitInNewThread;                     
        QPluginLoader *m_loader;

        virtual void importItomApi(void** apiPtr) = 0; //this methods are implemented in the plugin itsself. Therefore place ITOM_API right after Q_INTERFACE in the header file and replace Q_EXPORT_PLUGIN2 by Q_EXPORT_PLUGIN2_ITOM in the source file.
        virtual void importItomApiGraph(void** apiPtr) = 0;
        inline bool hasGuiSupport()
        {
            if (qobject_cast<QApplication*>(QCoreApplication::instance()))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

    public:
        void **m_apiFunctionsBasePtr;
        void **m_apiFunctionsGraphBasePtr;

        virtual ~AddInInterfaceBase();

        AddInInterfaceBase() :
            m_type(0), m_version(CREATEVERSION(0, 0, 0)), m_filename(""),
            m_maxItomVer(MAXVERSION), m_minItomVer(MINVERSION),
            m_author(""), m_description(""), m_detaildescription(""), m_license("LGPL with ITO itom-exception"), m_aboutThis(""),
            /*m_enableAutoLoad(false),*/ m_autoLoadPolicy(ito::autoLoadNever),
            m_autoSavePolicy(ito::autoSaveNever), m_callInitInNewThread(true), m_apiFunctionsBasePtr(NULL), m_apiFunctionsGraphBasePtr(NULL), m_loader(NULL)
        { }

        inline int getType(void) const { return m_type; }
        inline int getVersion(void) const { return m_version; }
        inline int getMinItomVer(void) const { return m_minItomVer; }
        inline int getMaxItomVer(void) const { return m_maxItomVer; }

        inline bool getCallInitInNewThread(void) const { return m_callInitInNewThread; }

        inline tAutoLoadPolicy getAutoLoadPolicy(void) const { return m_autoLoadPolicy; }

        inline tAutoSavePolicy getAutoSavePolicy(void) const { return m_autoSavePolicy; }

        const QString getAuthor(void) const { return m_author; }
        const QString getDescription(void) const { return m_description; }
        const QString getDetailDescription(void) const { return m_detaildescription; }
        const QString getLicenseInfo(void) const { return m_license; }
        const QString getAboutInfo(void) const { return m_aboutThis; }
        const QString getFilename(void) const { return m_filename; }

        const ito::RetVal setFilename(const QString &name) { m_filename = name; return ito::retOk; }
        inline QList<ito::AddInBase *> getInstList(void) { return m_InstList; }
        inline const QList<ito::AddInBase *> getInstList(void) const { return m_InstList; }
        ito::RetVal closeInst(ito::AddInBase **addInInst);
        virtual QVector<ito::Param>* getInitParamsMand(void) { return &m_initParamsMand; }
        virtual QVector<ito::Param>* getInitParamsOpt(void) { return &m_initParamsOpt; }
        virtual ito::RetVal getAddInInst(ito::AddInBase **addInInst) = 0;
        void incRef(ito::AddInBase *addIn);
        void decRef(ito::AddInBase *addIn);
        int getRef(ito::AddInBase *addIn);
        int getInstCount() { return m_InstList.length(); }
        void setApiFunctions(void **apiFunctions);
        void setApiFunctionsGraph(void ** apiFunctionsGraph);
        inline void setLoader(QPluginLoader *loader) { m_loader = loader; }
        inline QPluginLoader * getLoader(void) { return m_loader; }

        bool event(QEvent *e);
    };

    //----------------------------------------------------------------------------------------------------------------------------------
    class ITOMCOMMONQT_EXPORT AddInBase : public QObject
    {
        Q_OBJECT

    public:

        struct AddInRef {
            AddInRef() : type(-1), ptr(0) {}
            AddInRef(void *p, int t) : type(t), ptr(p) {}
            int type;
            void *ptr;
        };

        const Param getParamRec(const QString name, bool *nameCheckOk = NULL) const;

        AddInInterfaceBase* getBasePlugin(void) const;

        ito::RetVal MoveToThread(void);

        /*
        Use the method setParam in order to change any parameter.

        \param paramNames [out]. The pointer contains a pointer to the map after the call of this function
        \return RetVal returns retOk.
        */
        inline const ito::RetVal getParamList(QMap<QString, Param> **paramNames) { *paramNames = &m_params; return ito::retOk; }

        /*
        \param [out] funcs is the pointer to a map, that points to the internal map of additional functions after the method-call.
        \return retOk
        \sa registerExecFunc
        */
        inline const ito::RetVal getExecFuncList(QMap<QString, ExecFuncParams> **funcs) { *funcs = &m_execFuncList; return ito::retOk; }

        int getID() const;

        inline QString getIdentifier() const { return m_identifier; }

        virtual int hasConfDialog(void);

        virtual const ito::RetVal showConfDialog(void);

        int createdByGUI() const;

        void setCreatedByGUI(int value);

        /*
        The reference counter is zero-based, hence, the value zero means that one reference is pointing to this instance
        */
        inline int getRefCount(void) const
        {
            return m_refCount;
        }

        /*
        \sa getDockWidget
        */
        bool hasDockWidget(void) const;

        /*
        \sa hasDockWidget
        */
        QDockWidget* getDockWidget(void) const;

        // doc in source
        virtual void dockWidgetDefaultStyle(bool &floating, bool &visible, Qt::DockWidgetArea &defaultArea) const;

        /*
        Any time-consuming operation of the plugin should regularly set the alive-flag to true
        by calling setAlive. The state of this flag is returned by this method and afterwards
        reset to 0. This method is thread-safe.

        \return current status of alive-flag (1 if "still alive", else 0)
        \sa setAlive
        */
        int isAlive(void)
        {
            //                QMutexLocker locker(&m_atomicMutex);
            int wasalive = m_alive;
            m_alive = 0;
            return wasalive;
        }

        /*
        This method is thread-safe.

        \sa isAlive
        */
        void setAlive(void)
        {
            //                QMutexLocker locker(&m_atomicMutex);
            m_alive = 1;
        }

        bool isInitialized(void) const;

        /*
        \param [in] initialized is the value to set
        */
        void setInitialized(bool initialized);

        /*
        This vector contains all plugin-instances, that have been passed to the init
        method of this plugin. The reference counter of these plugin is incremented at
        initialization of this plugin and decremented if this plugin will be destroyed.

        \sa AddInRef, init
        */
        QVector<ito::AddInBase::AddInRef *> * getArgAddIns(void) { return &m_hwDecList; }

        static int getMaximumThreadCount();
        static RetVal setMaximumThreadCount(int threadCount);

    protected:
        // constructor (doc in source)
        AddInBase();

        // destructor (doc in source)
        virtual ~AddInBase();

        void setIdentifier(const QString &identifier);

        //doc in source
        void createDockWidget(QString title, QDockWidget::DockWidgetFeatures features, Qt::DockWidgetAreas allowedAreas = Qt::AllDockWidgetAreas, QWidget *content = NULL);

        // doc in source
        ito::RetVal registerExecFunc(const QString funcName, const QVector<ito::Param> &paramsMand, const QVector<ito::Param> &paramsOpt, const QVector<ito::Param> &paramsOut, const QString infoString);

        void setBasePlugin(AddInInterfaceBase *base);

        QMap<QString, Param> m_params;                        

        QString m_identifier;                               

        inline bool hasGuiSupport()
        {
            if (qobject_cast<QApplication*>(QCoreApplication::instance()))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

    private:
        Q_DISABLE_COPY(AddInBase)

            
            inline void incRefCount(void);

        void decRefCount(void);


        int m_refCount;                                   
        QVector<ito::AddInBase::AddInRef *> m_hwDecList;  
        QMap<QString, ExecFuncParams> m_execFuncList;     
        QMutex m_refCountMutex;                           
        int m_alive;                                      
        QMutex m_atomicMutex;                             
        AddInBasePrivate *aibp;                           

        friend class AddInInterfaceBase;                  

        static int m_instCounter;
        static int maxThreadCount;                        

    signals:

        void parametersChanged(QMap<QString, ito::Param> params);

    public slots:
        virtual ito::RetVal init(QVector<ito::ParamBase> *paramsMand, QVector<ito::ParamBase> *paramsOpt, ItomSharedSemaphore *waitCond = NULL) = 0;
        virtual ito::RetVal close(ItomSharedSemaphore *waitCond) = 0;

        virtual ito::RetVal getParam(QSharedPointer<ito::Param> val, ItomSharedSemaphore *waitCond = NULL) = 0;
        virtual ito::RetVal setParam(QSharedPointer<ito::ParamBase> val, ItomSharedSemaphore *waitCond = NULL) = 0;

        ito::RetVal setParamVector(const QVector<QSharedPointer<ito::ParamBase> > values, ItomSharedSemaphore *waitCond = NULL);

        ito::RetVal getParamVector(const QVector<QSharedPointer<ito::Param> > values, ItomSharedSemaphore *waitCond = NULL);

        virtual ito::RetVal execFunc(const QString funcName, QSharedPointer<QVector<ito::ParamBase> > paramsMand, QSharedPointer<QVector<ito::ParamBase> > paramsOpt, QSharedPointer<QVector<ito::ParamBase> > paramsOut, ItomSharedSemaphore *waitCond = NULL);

        ito::RetVal moveBackToApplicationThread(ItomSharedSemaphore *waitCond = NULL);


        void sendParameterRequest(){ emit parametersChanged(m_params); };

    private slots:


        virtual void dockWidgetVisibilityChanged(bool /*visible*/) {};
    };

    //----------------------------------------------------------------------------------------------------------------------------------
    class ITOMCOMMONQT_EXPORT AddInDataIO : public AddInBase
    {
        Q_OBJECT

    private:
        Q_DISABLE_COPY(AddInDataIO)

    protected:
        virtual ~AddInDataIO();
        AddInDataIO();

        void runStatusChanged(bool deviceStarted);

        //void timerEvent (QTimerEvent *event) = 0; //implement this event in your plugin, if you are a device, which is accessible by any liveImage!!!

        QSet<QObject*> m_autoGrabbingListeners;  
        int m_timerID;               
        int m_timerIntervalMS;       
        bool m_autoGrabbingEnabled;  
    public:
        inline int getAutoGrabbing() { return m_autoGrabbingEnabled; }  
    signals:

        public slots :
            virtual ito::RetVal startDevice(ItomSharedSemaphore *waitCond);
        virtual ito::RetVal stopDevice(ItomSharedSemaphore *waitCond);
        virtual ito::RetVal acquire(const int trigger, ItomSharedSemaphore *waitCond = NULL);
        virtual ito::RetVal getVal(void* data, ItomSharedSemaphore *waitCond = NULL);
        virtual ito::RetVal getVal(QSharedPointer<char> data, QSharedPointer<int> length, ItomSharedSemaphore *waitCond = NULL);
        virtual ito::RetVal copyVal(void *dObj, ItomSharedSemaphore *waitCond);

        virtual ito::RetVal setVal(const char *data, const int length, ItomSharedSemaphore *waitCond = NULL);

        ito::RetVal enableAutoGrabbing(ItomSharedSemaphore *waitCond = NULL); //consider this method as final

        ito::RetVal disableAutoGrabbing(ItomSharedSemaphore *waitCond = NULL); //consider this method as final

        ito::RetVal setAutoGrabbingInterval(QSharedPointer<int> interval, ItomSharedSemaphore *waitCond = NULL); //consider this method as final

        ito::RetVal startDeviceAndRegisterListener(QObject* obj, ItomSharedSemaphore *waitCond = NULL); //consider this method as final

        ito::RetVal stopDeviceAndUnregisterListener(QObject* obj, ItomSharedSemaphore *waitCond = NULL); //consider this method as final
    };

    //----------------------------------------------------------------------------------------------------------------------------------


    class ITOMCOMMONQT_EXPORT AddInActuator : public AddInBase
    {
        Q_OBJECT

    private:
        Q_DISABLE_COPY(AddInActuator)

            bool m_interruptFlag;               
        QMutex m_interruptMutex;            
    protected:
        virtual ~AddInActuator();
        AddInActuator();

        QVector<int>    m_currentStatus;  
        QVector<double> m_currentPos;  
        QVector<double> m_targetPos;  
        bool isMotorMoving() const
        {
            foreach(const int &i, m_currentStatus)
            {
                if (i & ito::actuatorMoving)
                {
                    return true;
                }
            }
            return false;
        }

        void sendStatusUpdate(const bool statusOnly = false); /* emits actuatorStatusChanged signal with the vector of currentStatus (and currentPos if statusOnly = false) to notify connected listeners about the current status (and position)*/
        void sendTargetUpdate(); /* emits targetChanged with the vector of targetPositions to notify connected listeners about the change of the target position(s) */


        virtual ito::RetVal waitForDone(const int timeoutMS = -1, const QVector<int> axis = QVector<int>() /*if empty -> all axis*/, const int flags = 0 /*for your use*/) = 0;


        inline void setStatus(int &status, const int newFlags, const int keepMask = 0) { status = (status & keepMask) | newFlags; }


        inline void setStatus(const QVector<int> &axis, const int newFlags, const int keepMask = 0)
        {
            foreach(const int &i, axis)
            {
                setStatus(m_currentStatus[i], newFlags, keepMask);
            }
        }


        inline void replaceStatus(int &status, const int existingFlag, const int replaceFlag) { if (status & existingFlag) { status = (status ^ existingFlag) | replaceFlag; } }


        inline void replaceStatus(const QVector<int> &axis, const int existingFlag, const int replaceFlag)
        {
            foreach(const int &i, axis)
            {
                replaceStatus(m_currentStatus[i], existingFlag, replaceFlag);
            }
        }


        bool isInterrupted()
        {
            QMutexLocker locker(&m_interruptMutex);
            bool res = m_interruptFlag;
            m_interruptFlag = false;
            return res;
        }

    public:

        void setInterrupt()
        {
            QMutexLocker locker(&m_interruptMutex);
            m_interruptFlag = true;
        }



    signals:

        void actuatorStatusChanged(QVector<int> status, QVector<double> actPosition);


        void targetChanged(QVector<double> targetPositions);

        public slots:
        virtual ito::RetVal calib(const int axis, ItomSharedSemaphore *waitCond = NULL) = 0;
        virtual ito::RetVal calib(const QVector<int> axis, ItomSharedSemaphore *waitCond = NULL) = 0;
        virtual ito::RetVal setOrigin(const int axis, ItomSharedSemaphore *waitCond = NULL) = 0;
        virtual ito::RetVal setOrigin(const QVector<int> axis, ItomSharedSemaphore *waitCond = NULL) = 0;
        virtual ito::RetVal getStatus(QSharedPointer<QVector<int> > status, ItomSharedSemaphore *waitCond) = 0;
        virtual ito::RetVal getPos(const int axis, QSharedPointer<double> pos, ItomSharedSemaphore *waitCond) = 0;
        virtual ito::RetVal getPos(const QVector<int> axis, QSharedPointer<QVector<double> > pos, ItomSharedSemaphore *waitCond) = 0;
        virtual ito::RetVal setPosAbs(const int axis, const double pos, ItomSharedSemaphore *waitCond = NULL) = 0;
        virtual ito::RetVal setPosAbs(const QVector<int> axis, QVector<double> pos, ItomSharedSemaphore *waitCond = NULL) = 0;
        virtual ito::RetVal setPosRel(const int axis, const double pos, ItomSharedSemaphore *waitCond = NULL) = 0;
        virtual ito::RetVal setPosRel(const QVector<int> axis, QVector<double> pos, ItomSharedSemaphore *waitCond = NULL) = 0;

        virtual ito::RetVal requestStatusAndPosition(bool sendCurrentPos, bool sendTargetPos); //added 2014-03-04
    };

    //----------------------------------------------------------------------------------------------------------------------------------
    class ITOMCOMMONQT_EXPORT AddInAlgo : public AddInBase
    {
        Q_OBJECT

#if QT_VERSION < 0x050500
        //for >= Qt 5.5.0 see Q_ENUM definition below
        Q_ENUMS(tAlgoCategory)
        Q_ENUMS(tAlgoInterface)
#endif

    private:
        Q_DISABLE_COPY(AddInAlgo)

    public:
        typedef ito::RetVal(*t_filter)(QVector<ito::ParamBase> *paramsMand, QVector<ito::ParamBase> *paramsOpt, QVector<ito::ParamBase> *paramsOut);
        typedef QWidget*    (*t_algoWidget)(QVector<ito::ParamBase> *paramsMand, QVector<ito::ParamBase> *paramsOpt, ito::RetVal &retValue);
        typedef ito::RetVal(*t_filterParam)(QVector<ito::Param> *paramsMand, QVector<ito::Param> *paramsOpt, QVector<ito::Param> *paramsOut);

        enum tAlgoCategory
        {
            catNone = 0x0000, 
            catDiskIO = 0x0001, 
            catAnalyseDataObject = 0x0002, 
            catPlotDataObject = 0x0004 
        };

        enum tAlgoInterface
        {
            iNotSpecified = 0x0000, 
            iReadDataObject = 0x0001, 
            iWriteDataObject = 0x0002, 
            iReadPointCloud = 0x0004, 
            iWritePointCloud = 0x0008, 
            iReadPolygonMesh = 0x0010, 
            iWritePolygonMesh = 0x0020, 
            iPlotSingleObject = 0x0040  
        };

#if QT_VERSION >= 0x050500
        //Q_ENUM exposes a meta object to the enumeration types, such that the key names for the enumeration
        //values are always accessible.
        Q_ENUM(tAlgoCategory)
        Q_ENUM(tAlgoInterface)
#endif

        class FilterDef
        {
        public:
            FilterDef() :
                m_filterFunc(NULL),
                m_paramFunc(NULL),
                m_pBasePlugin(NULL),
                m_category(ito::AddInAlgo::catNone),
                m_interface(ito::AddInAlgo::iNotSpecified)
            {}

            FilterDef(AddInAlgo::t_filter filterFunc, AddInAlgo::t_filterParam filterParamFunc, QString description = QString(), ito::AddInAlgo::tAlgoCategory category = ito::AddInAlgo::catNone, ito::AddInAlgo::tAlgoInterface interf = ito::AddInAlgo::iNotSpecified, QString interfaceMeta = QString()) :
                m_filterFunc(filterFunc),
                m_paramFunc(filterParamFunc),
                m_pBasePlugin(NULL),
                m_description(description),
                m_category(category),
                m_interface(interf),
                m_interfaceMeta(interfaceMeta)
            {}

            virtual ~FilterDef() {}

            t_filter m_filterFunc;    
            t_filterParam m_paramFunc;    
            ito::AddInInterfaceBase *m_pBasePlugin;        
            QString m_name;                
            QString m_description;        
            ito::AddInAlgo::tAlgoCategory m_category;    
            ito::AddInAlgo::tAlgoInterface m_interface; 
            QString m_interfaceMeta;    
        private:
            FilterDef(const FilterDef & /*p*/); //disable copy constructor
        };

        class AlgoWidgetDef
        {
        public:
            AlgoWidgetDef() :
                m_widgetFunc(NULL),
                m_paramFunc(NULL),
                m_pBasePlugin(NULL),
                m_category(ito::AddInAlgo::catNone),
                m_interface(ito::AddInAlgo::iNotSpecified)
            {}

            AlgoWidgetDef(AddInAlgo::t_algoWidget algoWidgetFunc, AddInAlgo::t_filterParam algoWidgetParamFunc, QString description = QString(), ito::AddInAlgo::tAlgoCategory category = ito::AddInAlgo::catNone, ito::AddInAlgo::tAlgoInterface interf = ito::AddInAlgo::iNotSpecified, QString interfaceMeta = QString()) :
                m_widgetFunc(algoWidgetFunc),
                m_paramFunc(algoWidgetParamFunc),
                m_pBasePlugin(NULL),
                m_description(description),
                m_category(category),
                m_interface(interf),
                m_interfaceMeta(interfaceMeta)
            {}

            virtual ~AlgoWidgetDef() {}    

            t_algoWidget m_widgetFunc;    
            t_filterParam m_paramFunc;    
            ito::AddInInterfaceBase *m_pBasePlugin;        
            QString m_name;                
            QString m_description;        
            ito::AddInAlgo::tAlgoCategory m_category;    
            ito::AddInAlgo::tAlgoInterface m_interface; 
            QString m_interfaceMeta;    

        private:
            AlgoWidgetDef(const AlgoWidgetDef & /*p*/); //disable copy constructor
        };

        ito::RetVal getFilterList(QHash<QString, FilterDef *> &fList) const;
        ito::RetVal getAlgoWidgetList(QHash<QString, AlgoWidgetDef *> &awList) const;
        ito::RetVal rejectFilter(const QString &name);
        ito::RetVal rejectAlgoWidget(const QString &name);

    protected:
        virtual ~AddInAlgo();
        AddInAlgo();
        QHash<QString, FilterDef *> m_filterList;
        QHash<QString, AlgoWidgetDef *> m_algoWidgetList;

        static ito::RetVal prepareParamVectors(QVector<ito::Param> *paramsMand, QVector<ito::Param> *paramsOpt, QVector<ito::Param> *paramsOut)
        {
            if (!paramsMand)
            {
                return RetVal(ito::retError, 0, tr("uninitialized vector for mandatory parameters!").toLatin1().data());
            }
            if (!paramsOpt)
            {
                return RetVal(ito::retError, 0, tr("uninitialized vector for optional parameters!").toLatin1().data());
            }
            if (!paramsOut)
            {
                return RetVal(ito::retError, 0, tr("uninitialized vector for output parameters!").toLatin1().data());
            }
            paramsMand->clear();
            paramsOpt->clear();
            paramsOut->clear();
            return ito::retOk;
        }

        public slots:
        virtual ito::RetVal getParam(QSharedPointer<ito::Param> /*val*/, ItomSharedSemaphore * /*waitCond*/ = NULL) { return ito::retOk; }
        virtual ito::RetVal setParam(QSharedPointer<ito::ParamBase> /*val*/, ItomSharedSemaphore * /*waitCond*/ = NULL) { return ito::retOk; }
    };

    //----------------------------------------------------------------------------------------------------------------------------------
} // namespace ito

#endif //#if !defined(Q_MOC_RUN) || defined(ITOMCOMMONQT_MOC)

//###########################################################################################################
//   Interface version:
//###########################################################################################################
//
//
// Please change the interface version, if you made any changes to this interface, files located in the common folder or to the dataObject.
//
// To add a new version, do the following steps
//
// 1. append the string behind the variable ito_AddInInterface_CurrentVersion (e.g. ito.AddIn.InterfaceBase/1.1) to the array ito_AddInInterface_OldVersions
// 2. change the version number in the string ito_AddInInterface_CurrentVersion
// 3. if the AddInInterface version number is incremented, the ito.AbstractItomDesignerPlugin number in AbstractItomDesignerPlugin.h must be incremented as well.
//
//
// This helps, that deprecated or "future" plugins, which fit not to the current implementation of the interface will not be loaded
// but a sophisticated error message is shown.

static const char* ito_AddInInterface_OldVersions[] = {
    "ito.AddIn.InterfaceBase/1.0",   //version from start of development until 2012-10-11
    "ito.AddIn.InterfaceBase/1.1",   //version until 2012-10-15 (outdated due to changes in dataObject)
    "ito.AddIn.InterfaceBase/1.1.1", //version until 2012-10-21 (outdated due to small changes in addInInterface)
    "ito.AddIn.InterfaceBase/1.1.2", //version until 2012-10-30 (outdated due to small changes in addInInterface)
    "ito.AddIn.InterfaceBase/1.1.3", //version until 2012-11-09 (outdated due to changes in the checkData()-function in addInGrabber)
    "ito.AddIn.InterfaceBase/1.1.4", //version until 2012-11-12 (outdated due to changes in the DataObject)
    "ito.AddIn.InterfaceBase/1.1.5", //version until 2012-11-18 (outdated: changes in the API structure)
    "ito.AddIn.InterfaceBase/1.1.6", //version until 2012-12-20 (outdated: added paramBase metatype)
    "ito.AddIn.InterfaceBase/1.1.7", //version until 2013-01-17 (outdated: last version for itom version 1.0.5)
    "ito.AddIn.InterfaceBase/1.1.8", //version until 2013-01-23 (outdated: changes in auto-grabbing of cameras, first interface for itom version 1.0.6)
    "ito.AddIn.InterfaceBase/1.1.9", //version until 2013-03-04 (outdated: changes in dataObjectHelper)
    "ito.AddIn.InterfaceBase/1.1.10",//version until 2013-03-12 (outdated: Added license and about string to the plugin)
    "ito.AddIn.InterfaceBase/1.1.11",//version until 2013-03-22 (outdated: bugfix in ito::ParamBase)
    "ito.AddIn.InterfaceBase/1.1.12",//version until 2013-03-25 (outdated: changes in api)
    "ito.AddIn.InterfaceBase/1.1.13",//version until 2013-04-08 (outdated: removed transpose flag in dataObject)
    "ito.AddIn.InterfaceBase/1.1.14",//version until 2013-04-17 (outdated: uniqueID and identifier inserted/changed)
    "ito.AddIn.InterfaceBase/1.1.15",//version until 2013-04-23 (outdated: made some tag-space related methods non-inline (due to linker errors in MSVC))
    "ito.AddIn.InterfaceBase/1.1.16",//version until 2013-06-07 (outdated: added qpluginloader to the interface for cleaner unloading of plugins)
    "ito.AddIn.InterfaceBase/1.1.17",//version until 2013-06-11 (outdated: apis extended, changes in param-class)
    "ito.AddIn.InterfaceBase/1.1.18",//version until 2013-06-18 (outdated: iterator and constIterator introduced for dataObject)
    "ito.AddIn.InterfaceBase/1.1.19",//version until 2013-08-15 (outdated: operators +, +=, -, -= introduced for scalar operands)
    "ito.AddIn.InterfaceBase/1.1.20",//version until 2013-10-10 (outdated: RGBA-type introduced into dataObjectTypes)
    "ito.AddIn.InterfaceBase/1.1.21",//version until 2013-10-15 (outdated: getSize(..) and getTotalSize(..) return int now and -1 if error. Consistency to documented behaviour)
    "ito.AddIn.InterfaceBase/1.1.22",//version until 2013-10-27 (outdated: class Rgba32Base in typedefs.h and inherited class Rgba32 in color.h introduced, improved data() method in dataObj)
    "ito.AddIn.InterfaceBase/1.1.23",//version until 2013-12-17 (outdated: changed dataObject internal size parameters (back) from size_t to int - hopfully last time)
    "ito.AddIn.InterfaceBase/1.1.24",//version until 2014-02-09 (outdated: restructuring to itomCommonLib and itomCommonQtLib for a better binary compatibility)
    "ito.AddIn.InterfaceBase/1.2.0", //outdated on 2014-03-14 due to change in AddInDataIO::setVal(const char *data, const int length, ItomSharedSemaphore *waitCond = NULL); (const void *data changed to const char *data) (Qt5 bugfix)
    "ito.AddIn.InterfaceBase/1.2.1", //outdated on 2014-10-06 due to changes in APIs, retVal.h and itomWidgets-project. The next version 1.3.0 is the version for the setup 1.3.0.
    "ito.AddIn.InterfaceBase/1.3.0", //outdated on 2014-10-27 due to insertion of ito::AutoInterval object and addition of further ito::ParamMeta classes.
    "ito.AddIn.InterfaceBase/1.3.1", //outdated on 2015-03-01 due to rework on data object
    "ito.AddIn.InterfaceBase/1.4.0", //outdated on 2015-07-03 due to removal of lock mechanism in data object, add of embedded line plots, qt5 incompatiblity changes and some refinements in addInInterface
    "ito.AddIn.InterfaceBase/2.0.0", //outdated on 2015-12-04 due to improvements in plot/figure interfaces, removal of deprecated classes helperActuator and helperGrabber and further removal of deprecated items
    "ito.AddIn.InterfaceBase/2.1.0", //outdated on 2016-02-01 due to improvements in PluginThreadCtrl, ActuatorThreadCtrl and DataIoThreadCtrl (as replacement for removed classes helperActuator and helperGrabber), new method ito::DataObject::getStep and some smaller rearrangements
    "ito.AddIn.InterfaceBase/2.2.0", //outdated on 2016-02-19 due to crash fixes if the main mindow is deleted and implicitely closes dock widgets of plugins, that are currently blocked by any other operation.
    "ito.AddIn.InterfaceBase/2.3.0", //outdated on 2016-06-14 due to changes in signal definitions in plots, introduction of complex and complexArray types in ParamBase and further smaller changes.
    "ito.AddIn.InterfaceBase/2.4.0", //outdated on 2016-07-12 due to new library itomCommonPlotLib.
    "ito.AddIn.InterfaceBase/2.5.0", //outdated on 2017-02-05 due to changes in ParamMeta classes
    "ito.AddIn.InterfaceBase/2.6.0", //outdated on 2017-02-05 since the AddInManager has been separated into its own shared library
    NULL
};

//these defines exist since itom 1.3.1
#define CREATE_ADDININTERFACE_VERSION_STR(major,minor,patch) "ito.AddIn.InterfaceBase/"#major"."#minor"."#patch
#define CREATE_ADDININTERFACE_VERSION(major,minor,patch) ((major<<16)|(minor<<8)|(patch))

#define ITOM_ADDININTERFACE_MAJOR 3
#define ITOM_ADDININTERFACE_MINOR 0
#define ITOM_ADDININTERFACE_PATCH 0
#define ITOM_ADDININTERFACE_VERSION CREATE_ADDININTERFACE_VERSION(ITOM_ADDININTERFACE_MAJOR,ITOM_ADDININTERFACE_MINOR,ITOM_ADDININTERFACE_PATCH)
static const char* ito_AddInInterface_CurrentVersion = CREATE_ADDININTERFACE_VERSION_STR(3, 0, 0); //results in "ito.AddIn.InterfaceBase/x.x.x"; (the numbers 1,3,1 can not be replaced by the macros above. Does not work properly)



Q_DECLARE_INTERFACE(ito::AddInInterfaceBase, ito_AddInInterface_CurrentVersion /*"ito.AddIn.InterfaceBase/1.1"*/)

#endif