itom 1.3.0
D:/git-itom/sources/itom/Qitom/organizer/addInManager.h
00001 /* ********************************************************************
00002     itom software
00003     URL: http://www.uni-stuttgart.de/ito
00004     Copyright (C) 2013, Institut für Technische Optik (ITO),
00005     Universität Stuttgart, Germany
00006 
00007     This file is part of itom.
00008   
00009     itom is free software; you can redistribute it and/or modify it
00010     under the terms of the GNU Library General Public Licence as published by
00011     the Free Software Foundation; either version 2 of the Licence, or (at
00012     your option) any later version.
00013 
00014     itom is distributed in the hope that it will be useful, but
00015     WITHOUT ANY WARRANTY; without even the implied warranty of
00016     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
00017     General Public Licence for more details.
00018 
00019     You should have received a copy of the GNU Library General Public License
00020     along with itom. If not, see <http://www.gnu.org/licenses/>.
00021 *********************************************************************** */
00022 
00023 #ifndef ADDINMANAGER_H
00024 #define ADDINMANAGER_H
00025 
00026 #include "../global.h"
00027 
00028 #include "common/addInInterface.h"
00029 #include "DataObject/dataobj.h"
00030 #if ITOM_POINTCLOUDLIBRARY > 0
00031     #include "PointCloud/pclStructures.h"
00032 #endif
00033 #include "../models/PlugInModel.h"
00034 #include "algoInterfaceValidator.h"
00035 
00036 //#include <qcoreapplication.h>
00037 #include <qmetatype.h>
00038 #include <qvector.h>
00039 #include <qsharedpointer.h>
00040 #include <qhash.h>
00041 #include <qtimer.h>
00042 #include <qtranslator.h>
00043 #include <qpointer.h>
00044 
00045 // in the invokeMethod function parameters are passed with the Q_ARG macro, which works only with preregistered data types
00046 // the registration of "new" data types is done in two steps. First they are declared with the Q_DECLARE_METATYPE macro
00047 // second they are registered for use with the function qRegisterMetaType. For the data types used within the iTom plugin
00048 // system this is done here and in the constructor of the AddInManager
00049 Q_DECLARE_METATYPE(ItomSharedSemaphore *)
00050 Q_DECLARE_METATYPE(const char *)
00051 Q_DECLARE_METATYPE(const char **)
00052 Q_DECLARE_METATYPE(char *)
00053 Q_DECLARE_METATYPE(char **)
00054 Q_DECLARE_METATYPE(double)
00055 Q_DECLARE_METATYPE(double *)
00056 Q_DECLARE_METATYPE(const double *)
00057 Q_DECLARE_METATYPE(int *)
00058 Q_DECLARE_METATYPE(const int *)
00059 Q_DECLARE_METATYPE(ito::AddInInterfaceBase *)
00060 Q_DECLARE_METATYPE(ito::AddInBase *)
00061 Q_DECLARE_METATYPE(ito::AddInBase **)
00062 Q_DECLARE_METATYPE(ito::AddInDataIO **)
00063 Q_DECLARE_METATYPE(ito::AddInActuator **)
00064 Q_DECLARE_METATYPE(ito::AddInAlgo **)
00065 //Q_DECLARE_METATYPE(ito::ActuatorAxis **)
00066 Q_DECLARE_METATYPE(ito::RetVal *)
00067 Q_DECLARE_METATYPE(ito::RetVal)
00068 //Q_DECLARE_METATYPE(const void*)
00069 Q_DECLARE_METATYPE(QVector<ito::Param> *)
00070 Q_DECLARE_METATYPE(QVector<ito::ParamBase> *)
00071 Q_DECLARE_METATYPE(QVector<int>)
00072 Q_DECLARE_METATYPE(QVector<double>)
00073 
00074 Q_DECLARE_METATYPE(QSharedPointer<double> )
00075 Q_DECLARE_METATYPE(QSharedPointer<int>)
00076 Q_DECLARE_METATYPE(QSharedPointer<QVector<double> >)
00077 Q_DECLARE_METATYPE(QSharedPointer<char>)
00078 Q_DECLARE_METATYPE(QSharedPointer<ito::Param>)
00079 Q_DECLARE_METATYPE(QSharedPointer<ito::ParamBase>)
00080 
00081 Q_DECLARE_METATYPE(QVector<QSharedPointer<ito::ParamBase> >)
00082 Q_DECLARE_METATYPE(StringMap)
00083 
00084 Q_DECLARE_METATYPE(ito::DataObject)
00085 
00086 
00087 namespace ito
00088 {
00089     
00090 
00100     class AddInManager : public QObject
00101     {
00102         Q_OBJECT
00103 
00104         public:
00105             static AddInManager * getInstance(void);
00106             static RetVal closeInstance(void);
00107             const RetVal scanAddInDir(const QString &path);
00108             inline const QList<QObject *> * getDataIOList(void) const { return &m_addInListDataIO; }
00109             inline const QList<QObject *> * getActList(void)    const { return &m_addInListAct; }
00110             inline const QList<QObject *> * getAlgList(void)    const { return &m_addInListAlgo; }
00111             inline const QHash<QString, ito::AddInAlgo::FilterDef *>     * getFilterList(void)     const { return &m_filterList;     }
00112             inline const QHash<QString, ito::AddInAlgo::AlgoWidgetDef *> * getAlgoWidgetList(void) const { return &m_algoWidgetList; }
00113             const ito::FilterParams* getHashedFilterParams(ito::AddInAlgo::t_filterParam filterParam) const;
00114             const QList<PluginLoadStatus> getPluginLoadStatus() const { return m_pluginLoadStatus; }
00115             inline const AlgoInterfaceValidator * getAlgoInterfaceValidator(void) const { return m_algoInterfaceValidator; }
00116 
00117             const ito::AddInAlgo::AlgoWidgetDef * getAlgoWidgetDef( QString algoWidgetName, QString algoPluginName = QString() );
00118 
00119             inline PlugInModel * getPluginModel(void) { return &m_plugInModel; }
00120             const RetVal reloadAddIn(const QString &name);
00121             inline int getNumTotItems(void) const { return m_addInListDataIO.size() + m_addInListAct.size() + m_addInListAlgo.size(); }
00122             void * getAddInPtr(const int itemNum)
00123             {
00124                 int num = itemNum;
00125 
00126                 if (num < m_addInListAct.size())
00127                 {
00128                     return (void *)m_addInListAct[num];
00129                 }
00130                 else if (num -= m_addInListAct.size(), num < m_addInListAlgo.size())
00131                 {
00132                     return (void *)m_addInListAlgo[num];
00133                 }
00134                 else if (num -= m_addInListAlgo.size(), num < m_addInListDataIO.size())
00135                 {
00136                     return (void *)m_addInListDataIO[num];
00137                 }
00138                 else
00139                 {
00140                     return NULL;
00141                 }
00142             }
00143             int getItemNum(const void *item)
00144             {
00145                 int num = 0;
00146                 if ((num = m_addInListAct.indexOf((QObject*)item)) != -1)
00147                 {
00148                     return num;
00149                 }
00150                 else if ((num = m_addInListAlgo.indexOf((QObject*)item)) != -1)
00151                 {
00152                     return num + m_addInListAct.size();
00153                 }
00154                 else if ((num = m_addInListDataIO.indexOf((QObject*)item)) != -1)
00155                 {
00156                     return num + m_addInListAct.size() + m_addInListAlgo.size();
00157                 }
00158                 else
00159                 {
00160                     return -1;
00161                 }
00162             }
00163             int getItemIndexInList(const void *item)
00164             {
00165                 int num = 0;
00166                 if ((num = m_addInListAct.indexOf((QObject*)item)) != -1)
00167                 {
00168                     return num;
00169                 }
00170                 else if ((num = m_addInListAlgo.indexOf((QObject*)item)) != -1)
00171                 {
00172                     return num;
00173                 }
00174                 else if ((num = m_addInListDataIO.indexOf((QObject*)item)) != -1)
00175                 {
00176                     return num;
00177                 }
00178                 else
00179                 {
00180                     return -1;
00181                 }
00182             }
00183             int getPluginNum(const QString &name, ito::AddInInterfaceBase *&addIn)
00184             {
00185 
00186                 addIn = NULL;
00187 //                int num = -1;
00188                 for (int n = 0; n < m_addInListAct.size(); n++)
00189                 {
00190                     if ((m_addInListAct[n])->objectName() == name)
00191                     {
00192                         addIn = (ito::AddInInterfaceBase*)m_addInListAct[n];
00193                         return n;
00194                     }
00195                 }
00196                 for (int n = 0; n < m_addInListDataIO.size(); n++)
00197                 {
00198                     if ((m_addInListDataIO[n])->objectName() == name)
00199                     {
00200                         addIn = (ito::AddInInterfaceBase*)m_addInListDataIO[n];
00201                         return n;
00202                     }
00203                 }
00204                 for (int n = 0; n < m_addInListAlgo.size(); n++)
00205                 {
00206                     if ((m_addInListAlgo[n])->objectName() == name)
00207                     {
00208                         addIn = (ito::AddInInterfaceBase*)m_addInListAlgo[n];
00209                         return n;
00210                     }
00211                 }
00212                 return -1;
00213             }
00214 
00215 //            inline void updateModel(void) { m_addInModel.update(); }
00216             inline void updateModel(void) { m_plugInModel.update(); }
00217             const RetVal saveParamVals(ito::AddInBase *plugin);
00218             const RetVal loadParamVals(ito::AddInBase *plugin);
00219             const RetVal getInitParams(const QString &name, const int pluginType, int *pluginNum, QVector<ito::Param> *&paramsMand, QVector<ito::Param> *&paramsOpt);
00220             const RetVal getPluginInfo(const QString &name, int &pluginType, int &pluginNum, int &version, QString &typeString, QString &author, QString &description, QString &detaildescription, QString &license, QString &about);
00221             const RetVal incRef(ito::AddInBase *plugin);
00222             const RetVal decRef(ito::AddInBase **plugin);
00223 
00224             bool isPluginInstanceDead(const ito::AddInBase *plugin) const;
00225 
00226             const QList<ito::AddInAlgo::FilterDef *> getFilterByInterface(ito::AddInAlgo::tAlgoInterface iface, const QString tag = QString::Null()) const;
00227             const QList<ito::AddInAlgo::FilterDef *> getFiltersByCategory(ito::AddInAlgo::tAlgoCategory cat) const;
00228             const QList<ito::AddInAlgo::FilterDef *> getFilterByInterfaceAndCategory(ito::AddInAlgo::tAlgoInterface iface, ito::AddInAlgo::tAlgoCategory cat, const QString tag = QString::Null()) const;
00229 
00230         protected:
00231 
00232             RetVal initDockWidget(const ito::AddInBase *addIn);
00233             RetVal loadAddIn(QString &filename);
00234 
00235             RetVal loadAddInDataIO(QObject *plugin, ito::PluginLoadStatus &pluginLoadStatus);
00236             RetVal loadAddInActuator(QObject *plugin, ito::PluginLoadStatus &pluginLoadStatus);
00237             RetVal loadAddInAlgo(QObject *plugin, ito::PluginLoadStatus &pluginLoadStatus);
00238 
00239             RetVal registerPluginAsDeadPlugin(ito::AddInBase *addIn);
00240 
00241 
00242         private:
00243             AddInManager(void);
00244             AddInManager(AddInManager  &/*copyConstr*/) : QObject() {}
00245             ~AddInManager(void);
00246             QVector<QTranslator*> m_Translator;
00247 
00248             static AddInManager *m_pAddInManager;
00249             static QList<QObject *> m_addInListDataIO;
00250             static QList<QObject *> m_addInListAct;
00251             static QList<QObject *> m_addInListAlgo;
00252             static QHash<QString, ito::AddInAlgo::FilterDef *> m_filterList;
00253             static QMultiHash<QString, ito::AddInAlgo::FilterDef *> m_filterListInterfaceTag; //hash value is "{interface-number}_{tag}"
00254             static QHash<QString, ito::AddInAlgo::AlgoWidgetDef *> m_algoWidgetList;
00255             static QHash<void*, ito::FilterParams *> filterParamHash;
00256             static QList<PluginLoadStatus> m_pluginLoadStatus;
00257 
00258             AlgoInterfaceValidator *m_algoInterfaceValidator;
00259 
00260             //AddInModel m_addInModel;
00261             PlugInModel m_plugInModel;
00262 
00263             QList< QPointer<ito::AddInBase> > m_deadPlugins;
00264             QTimer m_deadPluginTimer;
00265 /*
00267             class AddInSingleton
00268             {
00269                 public:
00270                     ~AddInSingleton()
00271                     {
00272                         #pragma omp critical
00273                         {
00274                             if( AddInManager::m_pAddInManager != NULL)
00275                             {
00276                                 delete AddInManager::m_pAddInManager;
00277                                 AddInManager::m_pAddInManager = NULL;
00278                             }
00279                         }
00280                     }
00281             };
00282             friend class AddInSingleton;
00283 */
00284         signals:
00285             void splashLoadMessage(const QString &message, int alignment = Qt::AlignLeft, const QColor &color = Qt::black);
00286 
00287         public slots:
00288             ito::RetVal showConfigDialog(ito::AddInBase *addin, ItomSharedSemaphore *waitCond = NULL);
00289             ito::RetVal showDockWidget(ito::AddInBase *addin, int visible, ItomSharedSemaphore *waitCond = NULL);
00290 
00291             ito::RetVal initAddIn(const int pluginNum, const QString &name, ito::AddInDataIO **addIn, QVector<ito::ParamBase> *paramsMand, QVector<ito::ParamBase> *paramsOpt, bool autoLoadPluginParams, ItomSharedSemaphore *aimWait = NULL);
00292             ito::RetVal initAddIn(const int pluginNum, const QString &name, ito::AddInActuator **addIn, QVector<ito::ParamBase> *paramsMand, QVector<ito::ParamBase> *paramsOpt, bool autoLoadPluginParams, ItomSharedSemaphore *aimWait = NULL);
00293             ito::RetVal initAddIn(const int pluginNum, const QString &name, ito::AddInAlgo **addIn, QVector<ito::ParamBase> *paramsMand, QVector<ito::ParamBase> *paramsOpt, bool autoLoadPluginParams, ItomSharedSemaphore *aimWait = NULL);
00294 
00295             ito::RetVal closeAddIn(ito::AddInBase **addIn, ItomSharedSemaphore *aimWait = NULL);
00296 
00297         private slots:
00298             RetVal closeDeadPlugins();
00299     };
00300 } //namespace ito
00301 
00302 #endif
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends