ModuleFeedbackManager.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 MODULE_FEEDBACK_MANAGER_H_
#define MODULE_FEEDBACK_MANAGER_H_

#include <util/coTypes.h>

#include <string>

#include <cover/ui/Owner.h>
namespace opencover {
namespace ui {
class Menu;
class Action;
class Button;
}
}

class cp3dplane;

namespace opencover
{
class RenderObject;
class ColorBar;
class coInteractor;
}

#include <osg/Node>
#include <osg/Geode>
#include <osg/MatrixTransform>

// this class manages the interaction (menu and execution)
// of a module (but not the icon)

namespace opencover
{

class PLUGIN_UTILEXPORT ModuleFeedbackManager
        : public ui::Owner
{
public:
    ModuleFeedbackManager(const opencover::RenderObject *, opencover::coInteractor *, const char *pluginName);
    ModuleFeedbackManager(const RenderObject *, const RenderObject *, const char *pluginName);
    virtual ~ModuleFeedbackManager();

    // returns true if inter comes from the same module: used in
    // ModuleFeedbackPlugin::add for adding or updating an entry in
    // ModuleFeedbackPlugin::_ComplexModuleList
    bool compare(coInteractor *inter);
    // returns true if name is an object name from the same module:
    // used in ModuleFeedbackPlugin::remove for deleting an entry
    // in ModuleFeedbackPlugin::_ComplexModuleList
    bool compare(const char *name);
    // returns true if this moduelFeedbackManager is for the same plugin
    bool comparePlugin(const char *pluginName);

    // called for menu update when a new object is received
    virtual void update(const RenderObject *container, coInteractor *);
    virtual void update(const RenderObject *container, const RenderObject *);

    // empty implementation
    virtual void preFrame();

    // empty implementation of 3DTex functionality
    virtual void update3DTex(std::string, cp3dplane *, const char *cmName);

    std::string ModuleName(const char *) const;
    std::string ModuleName()
    {
        return moduleName_;
    };

    // set checkbox and and hide geometry
    void setHideFromGui(bool);

    // set the case name and put item into this menu
    void setCaseFromGui(const char *casename);

    // set the a new name
    void setNameFromGui(const char *casename);

    // show/hide geometry
    virtual void hideGeometry(bool);

    //Transform geometry
    void setMatrix(float *row0, float *row1, float *row2, float *row3);

    //Transform geometry
    void addNodeToCase(osg::Node *node);

    //enable feed back to Colors module
    void addColorbarInteractor(coInteractor *i);

    // do hide button functionality
    virtual void triggerHide(bool state);

    opencover::coInteractor *getInteractor()
    {
        return inter_;
    }
    bool getSyncState();

protected:
    // helper for constructor
    void createMenu();
    void registerObjAtUi(std::string name);

    // helper for update
    void updateMenuNames();
    void updateColorBar(const RenderObject *container);

    // gets either from attribute OBJECTNAME or from the module name
    // a suggestion for the menu name, the result is kept in _menuName
    //std::string suggestMenuName();
    std::string getMenuName() const;

    ui::Menu *menu_ = nullptr; // the menu for the interaction of the module managed by the instance of this class
    ui::Button *hideCheckbox_ = nullptr; // hide geometry
    ui::Button *syncCheckbox_ = nullptr; // sync interaction
    ui::Action *newButton_ = nullptr; // copy this module
    ui::Action *deleteButton_ = nullptr; // delete this module
    ui::Button *executeCheckbox_ = nullptr; // execute module button
    //ui::coSubMenuItem *colorsButton_; // open colorbar
    opencover::coInteractor *inter_ = nullptr; // the last interaction got from the module at issue
    bool inExecute_; // switch checkbox off when new object arrived
    std::string menuName_; // name associated to _menuItem: its updated when a new object is received

    // Overload this function if you want to do anything before an EXEC
    // call is sent to a module. Always call it before doing an EXEC call!
    virtual void preExecCB(opencover::coInteractor *){}

    // search the corresponding node in sg
    osg::Node *findMyNode();
    std::vector<osg::Geode *> findMyGeode();

    std::string geomObjectName_;
    std::string containerObjectName_;
    std::string attrObjectName_;
    std::string attrPartName_;

    std::string initialObjectName_; //we have to save it for the grmsg, because _inter is not always valid
    osg::ref_ptr<osg::MatrixTransform> geometryCaseDCS_;

private:
    // it is used in ModuleFeedbackManager::compare(const char *name)
    std::string moduleName_;

    std::string pName_;

    ui::Menu *coviseMenu_ = nullptr;
    ui::Menu *parentMenu_ = nullptr;
    ui::Menu *caseMenu_ = nullptr;
    std::string caseName_;

    std::string visItemName_; //"Tracer_1..."
    std::string visMenuName_; // "Tracer_1"
    void sendHideMsg(bool);
    std::vector<osg::Geode *> findRecMyGeode(osg::Node *node);
    osg::ref_ptr<osg::Node> myNode_;
    osg::ref_ptr<osg::Group> myNodesParent_;
};
}
#endif