telPlugin.h

Go to the documentation of this file.

#ifndef telPluginH
#define telPluginH
#include <sstream>
#include <string>
#include "telCoreExporter.h"
#include "telPluginsManagerSettings.h"
#include "telProperties.h"

namespace rr
{
class RoadRunner;
}

namespace tlp
{
    using rr::RoadRunner;
    using tlp::gEmptyString;
    using tlp::gNoneString;
    using std::string;
    class PluginManager;

typedef void    (event_cc *PluginEvent)(void* data1, void* data2);

//      CORE_DECLSPEC
class CORE_DECLSPEC Plugin
{
    friend PluginManager;
    public:
                                        Plugin( const string& name = gEmptyString,
                                                const string& cat = gNoneString,
                                                RoadRunner* aRR = NULL,
                                                const string& language = gNoneString,
                                                const PluginManager* pm = NULL);

        virtual                        ~Plugin();

        string                          getName();

        string                          getLibraryName();

        string                          getAuthor();

        string                          getCategory();

        string                          getDescription();

        string                          getHint();

        string                          getVersion();

        string                          getCopyright();

        RoadRunner*                     getRoadRunnerInstance();

        virtual string                  getInfo();

        virtual string                  getExtendedInfo();

        virtual unsigned char*          getManualAsPDF() const;

        virtual unsigned int            getPDFManualByteSize();

        virtual Properties*             getProperties(); //Each capability has a set of propertys

        virtual tlp::StringList          getPropertyNames();

        string                          getPluginPropertiesAsXML();

        virtual PropertyBase*           getProperty(const string& param);

        string                          getPropertyValueAsString(const string& param);

        void*                           getPropertyValueHandle(const string& param);

        void                            setPropertyByString(const string& nameOf, const char* value);

        void                            setPropertyValue(const string& nameOf, const void* value);
        void                            terminate();

        bool                            isBeingTerminated() const;

        bool                            wasTerminated() const;

        virtual bool                    isWorking() const;

        virtual bool                    assignRoadRunnerInstance(RoadRunner* rr);

        virtual bool                    assignOnStartedEvent(PluginEvent pluginStarted, void* userData1 = NULL, void* userData2 = NULL);

        virtual bool                    assignOnProgressEvent(PluginEvent pluginsProgress, void* userData1 = NULL, void* userData2 = NULL);

        virtual bool                    assignOnFinishedEvent(PluginEvent pluginsFinished, void* userData1 = NULL, void* userData2 = NULL);

        virtual string                  getResult();

        virtual bool                    resetPlugin();

        virtual string                  getStatus();

        virtual string                  getImplementationLanguage() = 0;


        bool                            hasStartedEvent() const;

        bool                            hasProgressEvent() const;

        bool                            hasFinishedEvent() const;

        void                            WorkStartedEvent(void* data1, void* data2);

        void                            WorkProgressEvent(void* data1, void* data2);

        void                            WorkFinishedEvent(void* data1, void* data2);

        pair<void*, void*>              getWorkStartedData();

        pair<void*, void*>              getWorkProgressData();

        pair<void*, void*>              getWorkFinishedData();

        virtual bool                    execute(bool inAThread = false) = 0;

        const PluginManager*            getPluginManager();


    protected:                          
        string                          mName;

        string                          mLibraryName;

        string                          mAuthor;

        string                          mCategory;

        string                          mDescription;

        string                          mHint;

        string                          mVersion;

        string                          mCopyright;

        string                          mImplementationLanguage;

        bool                            mTerminate;

        bool                            mIsWorking;

        RoadRunner                     *mRR;

        const PluginManager            *mPM;

        void                            setLibraryName(const string& libName);

        PluginEvent                     mWorkStartedEvent;

        PluginEvent                     mWorkProgressEvent;

        PluginEvent                     mWorkFinishedEvent;

        void                           *mWorkStartedData1;

        void                           *mWorkStartedData2;

        void                           *mWorkProgressData1;

        void                           *mWorkProgressData2;

        void                           *mWorkFinishedData1;

        void                           *mWorkFinishedData2;

         Properties                     mProperties;
};

}

#endif