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