coModule.h

Go to the documentation of this file.

/* This file is part of COVISE.
 
   You can use it under the terms of the GNU Lesser General Public License
   version 2.1 or later, see lgpl-2.1.txt.
 
 * License: LGPL 2+ */
 
#ifndef _CO_FEATURE_MODULE_H_
#define _CO_FEATURE_MODULE_H_
 
// 15.09.99
 
#include <do/coDoPolygons.h>
#include <appl/ApplInterface.h>
#include "coBooleanParam.h"
#include "coFileBrowserParam.h"
#include "coChoiceParam.h"
#include "coMaterialParam.h"
#include "coColormapChoiceParam.h"
#include "coColormapParam.h"
#include "coColorParam.h"
#include "coFloatParam.h"
#include "coFloatSliderParam.h"
#include "coFloatVectorParam.h"
#include "coIntScalarParam.h"
#include "coIntSliderParam.h"
#include "coIntVectorParam.h"
#include "coStringParam.h"
#include "coTimerParam.h"
#include "coInputPort.h"
#include "coOutputPort.h"
 
// forward declarations for pointers only
 
namespace covise
{
 
class coUifElem;
class coPort;
class coUifSwitch;
class coUifSwitchCase;
 
class APIEXPORT coModule : public Covise
{
 
private:
    enum
    {
        MAX_LEVELS = 64
    };
 
    enum
    {
        MAX_SOCKET = 256
    };
 
    coModule(const coModule &);
 
    coModule &operator=(const coModule &);
 
    // if we are in an open case : pointer to active case
    coUifSwitchCase *d_actCase[MAX_LEVELS];
    int d_numActCase;
 
    // if we are in an open switch : pointer to active case
    coUifSwitch *d_actSwitch[MAX_LEVELS];
    int d_numActSwitch;
 
    // list of registered sockets, number in list and handler Obj
    int d_socket[MAX_SOCKET];
    int d_numSocket;
 
    // static stubs for callback
    static void quitCallback(void *userData, void *callbackData);
    static void computeCallback(void *userData, void *callbackData);
    static void paramCallback(bool inMapLoading, void *userData, void *callbackData);
    static void feedbackCallback(void *userData, int len, const char *data);
    static void portCallback(void *userData, void *callbackData);
    static void addObjCallback(void *userData, void *callbackData);
 
    // our internal callback for changed parameters
    void localParam(bool inMapLoading, void *callbackData);
    // our internal callback connection changing ports
    void localPort(void *callbackData);
 
    // whether we automatically fire up all parameters first to secure the order
    int d_autoParamInit;
 
    // When this flag has been set, fire an EXEC message after returning
    // from this event
    int d_execFlag;
 
    // 'Grace period' to wait after self-exec to prevent overrinning next module
    float d_execGracePeriod;
 
    // Title of the module
    char *d_title;
 
    // initial Title of the module
    char *d_init_title;
 
    //send description to controller and UIF's
    void initDescription();
 
protected:
    // register a parameter port at the module: return 0 if ok, -1 on error
    int add_port(coPort *param);
 
    //should the module's name
    //be propagated as attribute?
    bool _propagateObjectName;
 
    // find element by name : derived classes might access directly
    coUifElem *findElem(const char *name);
 
    // list of all UIF Elements and number of Elements in list
    coUifElem *elemList[Covise::MAX_PORTS];
    int d_numElem;
 
    // our internal 'pre-compute' sets all non-immediate parameters
    virtual void localCompute(void *callbackData);
 
    // internal callback called if ADD_OBJECT messages arrive
    virtual void localAddObject(void *callbackData);
 
public:
    enum
    {
        FAIL = -1,
        SUCCESS = 0,
        STOP_PIPELINE = -1,
        CONTINUE_PIPELINE = 0
    };
 
    // ------------------ Constructor / destructor --------------------------
 
    coModule(int argc, char *argv[], const char *desc = NULL, bool propagate = false);
 
    virtual ~coModule();
 
    // --------------------- Utility functions ------------------------------
 
    bool GoodOctTrees(const coDistributedObject *grid, const coDistributedObject *otree);
 
    void selfExec();
 
    void setExecGracePeriod(float gracePeriod);
 
    // --------------------- Parameter switching ----------------------------
 
    coChoiceParam *paraSwitch(const char *name, const char *desc);
 
    int paraEndSwitch();
 
    int paraCase(const char *name);
 
    int paraCaseAdd(coPort *param);
 
    int paraEndCase();
 
    void autoInitParam(int value = 0);
 
    // -------------------- add a socket to listen to -----------------------
 
    void addSocket(int socket);
 
    void removeSocket(int socket);
 
    // --------------------- Covise Main-Loop et al -------------------------
 
    virtual void init(int argc, char *argv[]);
 
    virtual void start(int argc, char *argv[]);
 
    //   return either SUCCESS or FAIL
    virtual int compute(const char *port);
 
    //   return either SUCCESS or FAIL
    virtual int addObject(const char *objectNameToAdd, const char *objectNameToDelete);
 
    virtual void param(const char *paramName, bool inMapLoading);
 
    virtual void sockData(int sockNo);
 
    virtual void feedback(int len, const char *data);
 
    virtual void quit(void);
 
    virtual void postInst();
 
    virtual float idle();
 
    virtual void handleMessages(float time);
 
    virtual void mainLoop();
 
    void stopPipeline();
 
    // --------------------- Covise Main-Loop et al -------------------------
 
    coBooleanParam *addBooleanParam(const char *name, const char *desc);
 
    coFileBrowserParam *addFileBrowserParam(const char *name, const char *desc);
 
    coChoiceParam *addChoiceParam(const char *name, const char *desc);
 
    coColormapChoiceParam *addColormapChoiceParam(const char *name, const char *desc);
 
    coMaterialParam *addMaterialParam(const char *name, const char *desc);
 
    coColormapParam *addColormapParam(const char *name, const char *desc);
 
    coColorParam *addColorParam(const char *name, const char *desc);
 
    coFloatParam *addFloatParam(const char *name, const char *desc);
 
    coFloatSliderParam *addFloatSliderParam(const char *name, const char *desc);
 
    coFloatVectorParam *addFloatVectorParam(const char *name, const char *desc, int length = 3);
 
    coIntScalarParam *addInt32Param(const char *name, const char *desc);
 
    coIntSliderParam *addIntSliderParam(const char *name, const char *desc);
 
    coIntVectorParam *addInt32VectorParam(const char *name, const char *desc, int length = 3);
 
    coStringParam *addStringParam(const char *name, const char *desc);
 
    coTimerParam *addTimerParam(const char *name, const char *desc);
 
    coInputPort *addInputPort(const char *name, const char *types, const char *desc);
 
    coOutputPort *addOutputPort(const char *name, const char *types, const char *desc);
 
    // ------------------------------ Mapeditor message
    void setInfo(const char *value) const;
 
    void setTitle(const char *value);
    bool titleChanged()
    {
        return (strcmp(d_title, d_init_title) != 0);
    };
    const char *getTitle()
    {
        return d_title;
    };
};
 
class APIEXPORT coFunctionModule : public coModule
{
public:
    coFunctionModule(int argc, char *argv[], const char *desc = NULL, bool propagate = false)
        : coModule(argc, argv, desc, propagate)
    {
    }
 
    virtual ~coFunctionModule()
    {
    }
};
 
#define MODULE_MAIN(Category, Module)           \
    int main(int argc, char *argv[])            \
    {                                           \
        coModule *app = new Module(argc, argv); \
        app->start(argc, argv);                 \
    }
 
#define COMODULE
}
#endif