BM_OpState.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        BM_State.h
 *
 * COMMENTS:
 *      This is an "automated" state that links handles with op
 *      parameters.
 */

#ifndef __BM_OpState_H__
#define __BM_OpState_H__

#include "BM_API.h"
#include <UT/UT_SymbolTable.h>
#include <UI/UI_LookType.h>
#include <PRM/PRM_Template.h>
#include "BM_MoveTool.h"
#include "BM_State.h"

class OP_Node;
class BM_OpView;
class BM_Handle;
class UI_Feel;
class SI_Folders;
class BM_SceneManager;
class OPUI_Dialog;
class PI_OpHandleLink;

class opbm_DialogInfo;          // private to implementation
class opbm_PIContext;           // private to implementation
class opbm_UIInfo;              // private to implementation

// NOTE: If you change this default cursor, make sure you update
// RE/RE_Cursor to reflect it.
#define BM_DEFAULT_CURSOR       "iris"

class BM_API BM_OpState : public BM_State
{
public:
    // Class constructor and destructor.
             BM_OpState(BM_OpView &view, PI_StateTemplate &templ,
                        BM_SceneManager *scene_manager,
                        const char *cursor = BM_DEFAULT_CURSOR);
            ~BM_OpState() override;

    // Mouse events are passed on to all visible PI's.
    int                  handleMouseEvent (UI_Event *event) override;
    int                  handleMouseWheelEvent (UI_Event *event) override;

    // The name and type of this class:
    const char          *className() const override;

    void                 prepareDialogForDisplay() const override;
    int                  hasDialog() const override;
    UI_Feel             *dialogFeel() const override;

    int                  findPI(BM_OpHandleLink *pi) const override;

    // Called to give any PIs a chance to update (and optionally reveal) an
    // invisible handle rather than have the viewer switch to a move tool
    // state.  This method returns true if a handle was updated (i.e. the
    // viewer should not launch a move tool state).
    virtual bool         updateInvisiblePIHandleForMoveTool(
                            bool (*func)(BM_Handle *handle,
                                         BM_MoveTool::Type tool,
                                         unsigned vport_mask),
                            BM_MoveTool::Type tool,
                            unsigned vport_mask,
                            bool make_visible);

    // These set the flag as to whether or not we highlight ops
    // as we drop them.
    static int           getAutoHighlightFlag() { return theAutoHighlightFlag;}
    static void          setAutoHighlightFlag(int o) 
                                                { theAutoHighlightFlag = o; }
    /// Obtains the current global time.
    fpreal               getTime() const;

    bool                 getStateParmNames(
                            UT_StringArray &ret,
                            const char* prefix=nullptr ) override;
    bool                 evalStateParm(
                            const char *name,
                            UT_StringHolder &ret) override;
    bool                 setStateParm(
                            const char *name,
                            const UT_StringHolder &val) override;
    bool                 pressStateButton(const char *name) override;

    BM_OpHandleLink*                    piByRootDescription(const char *description);
    BM_OpHandleLink const*              piByRootDescription(const char *description) const;
    UT_ValArray<BM_OpHandleLink const*> piListByParmName(const char* parm_name) const;

    // Return the the operator name linked to the state. Defaults to the 
    // state template name. 
    // NOTE: This method is required in several places in Houdini where 
    // a state is being asked for an operator name. This is likey to be 
    // overriden by python state derived classes as the state name 
    // (template name) is not necessarily the same as the state operator 
    // name.
    virtual const char* getOperatorName() const;

protected:
          BM_OpView     &baseViewer()           { return myViewer; }
    const BM_OpView     &baseViewer() const     { return myViewer; }


    // Interrupt this state or resume its activity.
    void                 interrupt(BM_SimpleState * = 0) override;
    void                 resume   (BM_SimpleState * = 0) override;

    void                 getKeyResolveInfo(UI_KeyResolveInfo &info) override;

    // deal with events coming from either the popup menus or the keyboard
    int                  handleKeyTypeEvent(int key, UI_Event *event,
                                            BM_Viewport &viewport) override;
    // Handle transitory key presses.
    bool                 handleTransitoryKey(const UI_Event &event,
                                             int hotkey_id) override;

    // Create a PI and add it to the list of PI's.  If add_button is set,
    // a button is added to turn the PI on and off, and the makePIVisible
    // method is called when the button is pressed.  This button is added
    // to the specified folder.  On success, the index of the newly added
    // PI is returned.  -1 is returned on failure.
    int                  createPI(const char *pi_name, int opnum = -1,
                                  const char *description = 0);

    // allows base class to react when a new PI is created, appended or removed
    virtual void         onCreatePI(PI_OpHandleLink *pi);
    virtual void         onAppendPI(PI_OpHandleLink *pi);
    virtual void         onRemovePI(PI_OpHandleLink *pi);

    // Append an already existing PI and reflect it it our UI:
    int                  appendPI(BM_OpHandleLink *pi, int opnum = -1);
    virtual void         removePI(int pi_idx);
    void                 removeAllLinkedPIs();
    void                 removeLinkedPIByDescription(const char* descr_name);

          BM_OpHandleLink *pi(int index);
    const BM_OpHandleLink *pi(int index) const;
          BM_OpHandleLink *pi(const char *name);
    const BM_OpHandleLink *pi(const char *name) const;
    
    const char          *piDescription(int index) const;
    int                  piOpnum(int index) const;
    int                  numPIs() const { return myPIs.entries(); }

    // This method is called whenever the button is pressed to turn a PI
    // on or off.  It does not need to redraw the workbench.  It does nothing
    // in this base class.
    virtual void         makePIVisible(int pi_idx, int onoff);

    // Methods to combine different dialogs into the dialog for this state.
    int                  appendFolder(const char *folder_name);
    void                 appendFeelToFolder(const char *folder_name, 
                                            UI_Feel *child_feel);
    int                  appendDialogToFolder(const char *folder_name,
                                              BM_ParmState &state_or_handle);
    int                  appendDialogToFolder(const char *folder_name,
                                      OP_Node &op_node,
                                      PRM_Template::PRM_Export export_level);
    int                  appendThisStateDialogToFolder(const char *folder_name);
    int                  appendDividerToFolder(const char *folder_name);
    int                  appendTextToFolder(
                            const char *folder_name, const char *text,
                            UI_LookType look_type = UI_LOOK_HEADING_TEXT);
    int                  removeDialog(BM_ParmState &state);
    int                  removeDialog(OP_Node &op_node,
                                      PRM_Template::PRM_Export export_level);
    int                  removeFolder(const char *name, bool only_if_empty=false);

    // A subset of methods similar to the above. Use these methods if 
    // you need to remove the UI items individually with removeCachedUIItems. 
    // NOTE: The UI items are stored per folder_name and a unique cache_id.
    int                 appendDialogToFolder(const char *folder_name, 
                            BM_ParmState &state_or_handle, BM_Handle* handle);
    int                 appendDividerToFolder(const char *folder_name, BM_Handle* handle);
    int                 appendTextToFolder(const char *folder_name, const char *text, 
                            UI_LookType look_type, BM_Handle* handle);

    // Remove the UI items from a cache populated with the above methods. 
    int                 removeCachedUIItems(const char *folder_name, BM_Handle* handle);

    // Switches the UI to look at the folder given by name (if it exists)
    void                 switchToFolder(const char *name);

    // callback that is called when a dialog is deleted. It clears
    // any pointers that may become stale.
    virtual void         handleDialogDeleted( OPUI_Dialog *deleted_dialog );

    // This will remove all the dialogs which this state has created.
    // It is virtual as some derived states may have extra dialogs.
    virtual void         removeAllDialogs();
    void                 handlePIVisibilityChange(UI_Event *event);

    // Make the new, not-yet-connected node an output of the inputnode.
    // If not branching off, move inputnode's outputs to newnode's
    // output list.
    void                 connectNode(OP_Node &newnode, OP_Node &inputnode,
                                     int input_idx = 0, int branch_off = 0);

    // Stamp the node with the name of this state:
    void                 stampNode(OP_Node &newnode);

    // Return 1 if the node is generated by a state that matches our name,
    // or if the node's name matches our name:
    virtual int          matchesNode(OP_Node &node) const = 0;

    BM_OpView                           &myViewer;

    UT_ValArray<opbm_DialogInfo *>       myDialogs;
    UT_ValArray<opbm_PIContext *>        myPIs;
    UT_ValArray<UI_Feel *>               myMiscFeels;
    SI_Folders                          *myFolders;

    static const char                   *STATE_DIALOG_FOLDER;
    static const char                   *HANDLES_FOLDER;
    static const char                   *OP_DIALOG_FOLDER;
    static int                           theAutoHighlightFlag;

private:
    // callback that is called when a dialog is deleted. It clears
    // any pointers that may become stale.
    void                 dialogDeletedCallback( UI_Event* event );

    void                 buildStateParmPrefix(UT_WorkBuffer &buf, BM_OpHandleLink *pii, BM_Handle *h);
    BM_ParmState*        findStateParm( UT_String &name );
    
    opbm_UIInfo*         uiInfo(char const* folder_name, int64 cache_id);

    UT_Map<std::pair<int32 /*folder id*/, int64 /*ui cache id*/>, opbm_UIInfo> myUIInfoMap;
};

#endif