addInInterface.h

/* ********************************************************************
itom software
URL: http://www.uni-stuttgart.de/ito
Copyright (C) 2020, 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 "addInInterfaceVersion.h"
#include "sharedStructuresQt.h"
#include "sharedStructures.h"
#include "functionCancellationAndObserver.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>
#include <qscopedpointer.h>
#include <QtWidgets/qdockwidget.h>

//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


#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) \
      { \
      (*addInInst)->deleteLater(); \
      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; \
        }

//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: \
            virtual int getAddInInterfaceVersion() const \
                            { return ITOM_ADDININTERFACE_VERSION; } \
            //.

QT_BEGIN_NAMESPACE
class QPluginLoader;
QT_END_NAMESPACE

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, 
        actuatorEndSwitch1 = 0x0200,
        actuatorEndSwitch2 = 0x0400,    
        actuatorRefSwitch = 0x0800, 
        actuatorLeftRefSwitch = 0x1000, 
        actuatorRightRefSwitch = 0x2000, 
        actuatorRefSwitch1 = 0x1000,
        actuatorRefSwitch2 = 0x2000,
        //status flags
        actuatorAvailable = 0x4000, 
        actuatorEnabled = 0x8000, 
        actuatorError = 0x10000,/*axis has encountered error/reports error*/

        actMovingMask = actuatorUnknown | actuatorInterrupted | actuatorMoving | actuatorAtTarget | actuatorTimeout, 
        actEndSwitchMask = actuatorEndSwitch \
        | actuatorEndSwitch1 | actuatorEndSwitch2, 
        actRefSwitchMask = \
        actuatorRefSwitch \
        | actuatorRefSwitch1 | actuatorRefSwitch2, 
        actSwitchesMask = actEndSwitchMask | actRefSwitchMask,                                
        actStatusMask = actuatorAvailable | actuatorEnabled | actuatorError                     
    };

    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 AddInInterfaceBasePrivate; 
    class AddInActuatorPrivate;      
    class AddInDataIOPrivate;        
    class AddInAlgoPrivate;          

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

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

        QScopedPointer<AddInInterfaceBasePrivate> d_ptr; 
        Q_DECLARE_PRIVATE(AddInInterfaceBase);

    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;           
        tAutoLoadPolicy m_autoLoadPolicy;               
        tAutoSavePolicy m_autoSavePolicy;               
        bool m_callInitInNewThread;                     
        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();

        /* This method is automatically implemented by the PLUGIN_ITOM_API macro.
        The definition is 0xAABBCC where AA is the major, BB the minor and CC the patch.
        */
        virtual int getAddInInterfaceVersion() const = 0;

        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);

        void setLoader(QPluginLoader *loader);
        QPluginLoader * getLoader(void) const;

        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
        */
        int getRefCount(void) const;

        /*
        \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);

        /*
        This method is thread-safe.

        \sa isAlive
        */
        void setAlive(void);

        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; }

        /* This mutex has no designed task in the plugin, however it can be used by
        the user to for instance protect a sequence of different calls to this plugin.

        This can be important, if the plugin is for instance a communication object,
        that is used by different other hardware instances (e.g. a SerialIO to
        an arduino, that controls different motors, sensors etc.). Then, it might
        be important, that every hardware plugin object, that uses the serialIO
        plugin, can protect a setVal / getVal sequence without that any other
        plugin instance interrupts its. However, it is the task of the user to
        implement that protection. This mutex can only help for this.
        */
        QMutex& getUserMutex();

        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)

        
        void incRefCount(void);

        void decRefCount(void);

        QVector<ito::AddInBase::AddInRef *> m_hwDecList;  
        QMap<QString, ExecFuncParams> m_execFuncList;     
        
        QScopedPointer<AddInBasePrivate> d_ptr; 
        Q_DECLARE_PRIVATE(AddInBase);

        friend class AddInInterfaceBase;                  

        static int m_instCounter;
        static int maxThreadCount;                        

    Q_SIGNALS:

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

    public Q_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 Q_SLOTS:


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

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

    private:
        Q_DISABLE_COPY(AddInDataIO)

        QScopedPointer<AddInDataIOPrivate> d_ptr; 
        Q_DECLARE_PRIVATE(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; }  
    Q_SIGNALS:

    public Q_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 stop(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)

        QScopedPointer<AddInActuatorPrivate> d_ptr; 
        Q_DECLARE_PRIVATE(AddInActuator);

    protected:
        virtual ~AddInActuator();
        AddInActuator();

        QVector<int>    m_currentStatus;  
        QVector<double> m_currentPos;  
        QVector<double> m_targetPos;  
        bool isMotorMoving() const;

        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;


        void setStatus(int &status, const int newFlags, const int keepMask = 0);


        void setStatus(const QVector<int> &axis, const int newFlags, const int keepMask = 0);


        void replaceStatus(int &status, const int existingFlag, const int replaceFlag);


        void replaceStatus(const QVector<int> &axis, const int existingFlag, const int replaceFlag);


        void initStatusAndPositions(int numAxes, int status, double currentPosition = 0.0, double targetPosition = 0.0, bool sendUpdateSignals = true);


        bool isInterrupted();

    public:

        void setInterrupt();


        void resetInterrupt();


        ito::RetVal getLastSignalledStates(QVector<int> &status, QVector<double> &currentPos, QVector<double> &targetPos);

    Q_SIGNALS:

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


        void targetChanged(QVector<double> targetPositions);

    public Q_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 getStatus(const int axis, QSharedPointer<int> status, ItomSharedSemaphore *waitCond);
        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);
    };

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

    private:
        Q_DISABLE_COPY(AddInAlgo)

        QScopedPointer<AddInAlgoPrivate> d_ptr; 
        Q_DECLARE_PRIVATE(AddInAlgo);

    public:
        typedef ito::RetVal (*t_filter)     (QVector<ito::ParamBase> *paramsMand, QVector<ito::ParamBase> *paramsOpt, QVector<ito::ParamBase> *paramsOut);
        typedef ito::RetVal (*t_filterExt)  (QVector<ito::ParamBase> *paramsMand, QVector<ito::ParamBase> *paramsOpt, QVector<ito::ParamBase> *paramsOut, QSharedPointer<ito::FunctionCancellationAndObserver> observer);
        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  
        };

        //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)

        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 FilterDefExt : public FilterDef
        {
        public:
            FilterDefExt() :
                FilterDef(),
                m_filterFuncExt(NULL)
            {}

            FilterDefExt(AddInAlgo::t_filterExt filterFuncExt, AddInAlgo::t_filterParam filterParamFunc, 
                    QString description = QString(), ito::AddInAlgo::tAlgoCategory category = ito::AddInAlgo::catNone, 
                    ito::AddInAlgo::tAlgoInterface interf = ito::AddInAlgo::iNotSpecified, 
                    QString interfaceMeta = QString(), bool hasStatusInfo = true, bool isCancellable = true) :
                FilterDef(NULL, filterParamFunc, description, category, interf, interfaceMeta),
                m_filterFuncExt(filterFuncExt),
                m_hasStatusInformation(hasStatusInfo),
                m_isCancellable(isCancellable)
            {}

            virtual ~FilterDefExt() {}

            t_filterExt m_filterFuncExt;                      
            bool m_hasStatusInformation;                      
            bool m_isCancellable;                             

        private:
            FilterDefExt(const FilterDefExt & /*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);

    public Q_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)

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



#endif