MSS/MSS_SingleOpState.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.
 *
 * Produced by:
 *      Cristin Barghiel
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        MSS_SingleOpState.h
 *
 * COMMENTS:
 *      This is an "automated" state that links handles with op
 *      parameters.
 */

#ifndef __MSS_SingleOpState_H__
#define __MSS_SingleOpState_H__

#include "MSS_API.h"
#include <UT/UT_PtrArray.h>
#include <UT/UT_String.h>
#include <GU/GU_Selection.h>
#include <UI/UI_Value.h>
#include <UI/UI_Event.h>
#include <BM/BM_ResourceManager.h>
#include "MSS_SingleOpBaseState.h"

class UT_String;
class PRM_Template;
class DM_Workbench;
class OP3D_View;
class JEDI_View;
class OP3D_InputSelector;
class DM_Viewport;

class mss_InputSelectorUndoWorker;
class mss_UndoClearHandles;

class MSS_API MSS_SingleOpState : public MSS_SingleOpBaseState
{
    friend class mss_UndoClearHandles;
    friend class mss_UndoCreateHandles;
    friend class mss_InputSelectorUndoWorker;

public:
    // Class constructor and destructor.
             MSS_SingleOpState(JEDI_View &view, PI_StateTemplate &templ,
                               BM_SceneManager *scene, const char *cursor);
    virtual ~MSS_SingleOpState(void);

    // This constructor and parameter template list go into the
    // DM_StateTemplate for this state.
    static BM_State     *ourConstructor(BM_View &view, PI_StateTemplate &templ,
                                        BM_SceneManager *scene);
    static PRM_Template *ourTemplateList;

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

    // Enter or exit this state.
    virtual int          enter(BM_SimpleState::BM_EntryType how);
    virtual void         exit();
    virtual void         restart(void);
    virtual int          generate(BM_SimpleState::BM_EntryType how,
                                  bool insertmode = true);

    virtual int          hasLocates(void) const;

    // Check if we have to do anything if this node is deleted.  Return -1 if
    // we can't handle it, 0 otherwise.
    virtual int          handleNodeDeleted(OP_Node &node);

    // If a state generates a sop and displays it (eg. a hide sop), it
    // will want the state controller to ignore the change so the state
    // doesn't exit.
    virtual bool         ignoreDisplayFlagChange() const;

    void                 undoReselecting();

    // Return the feel for the RMB menu.
    virtual UI_Menu     *getSelectorMenu();

    // Return the menu feel for others to use:
    virtual UI_Menu     *getExtraStateMenu();

protected:
    // Quickly generate a node, connect it to the network if needed,
    // and stop generating. This method is called from generate().
    virtual void         doGenerate(void);

    // calls the selector render, if any
    virtual void         doRender(RE_Render *r, short, short, int ghost);

    // Respond to mouse and keyboard events.
    virtual int          handleMouseEvent(UI_Event *event);
    virtual bool         handleDoubleClickEvent(UI_Event *event);
    virtual int          handleKeyTypeEvent(UI_Event *event, BM_Viewport &);
    virtual bool         handleTransitoryKey(const UI_Event &event);

    // This depends on the secure selection button and 
    // whether a selector is active.
    virtual bool         isSelecting(void) const;

    // Interrupt this state or resume its activity. These methods should
    // be called by overlay states when entering and exiting respectively. 
    // Interrupt will leave the state in limbo and will usually turn off
    // the feed from the app; resume will do the opposite. interrupt()
    // should not change the modeler's current state. If 'state' is given, it
    // is the state that has interrupted/resumed us. This may be particularly
    // useful if we are interrupted by a handle (possibly ours).
    virtual void         resume(BM_SimpleState *state = 0);

    // Generate the necessary nodes and connect them
    virtual bool         generateAllNodes();

    // We're done selecting and we've been successful. In this class we simply 
    // clear the display.
    virtual void         doneSelecting(void);

    // If this state is reselecting and it tries to reselect within the same
    // node then that node's unique id is returned.  Otherwise, 0 is returned.
    virtual int          nodeIdToReselectWithin() const { return 0; }

    // Access to the list of selectors
    OP3D_InputSelector  *selector(int idx)
                         {
                             UT_ASSERT(idx >= 0);
                             UT_ASSERT(idx < mySelectors.entries());
                             return mySelectors(idx).mySelector;
                         }
    int                  getNumSelectors() const
                         {
                             return mySelectors.entries();
                         }

    virtual bool         isSelectorActive() const
                         { return (myCurrentSelector != 0); }

    virtual int          getToolboxCount() const;
    virtual UI_Feel     *getToolbox(int idx) const;

    virtual void         handleSelectorDone(UI_Event *);

                         // Override is subclasses to disable selector starting
                         // by this class.
    virtual bool         canStartSelectors() const          { return true; }

    virtual const PI_BindingSelectorInfo *findNextParmWithSelector(int idx) const;

    virtual void         addAnyReselectionUndos();

    virtual void         updateCurrentSelector(OP3D_InputSelector * /*cur_sel*/,
                            const PI_BindingSelectorInfo * /*selector_info*/)
                         { }

    virtual bool         getSelectionBoundingBox( DM_Viewport &vport,
                                                  UT_BoundingBox &bbox );

    virtual bool         getAllowQuickSelect() const    { return false; }

    virtual const char  *getTemplateName() const
                            { return (const char *)getTemplate().name(); }

    bool                 getFirstSelectionFlag() const
                            { return myFirstSelectionFlag; }
    void                 setFirstSelectionFlag(bool first)
                            { myFirstSelectionFlag = first; }

    virtual void         handleSelectionTypeChange(UI_Event *event);

private:
    // Append the specified node to the currently displayed sop.
    void                 appendNodeToDisplay(OP_Node &newnode);

    bool                 usesSelectors(); // sets mySelectableFlag

    void                 deleteSelectors();
    void                 setCurrentSelector(const PI_BindingSelectorInfo *
                                                                selector_info);
    void                 clearReselectLists();

    // When reselecting, store the selections on the input nodes.
    void                 storeSelectionsOfInputNodes();
    // Restore the selections on our inputs from the information stored above.
    void                 restoreCurrentSelectorSelections();
    // Helper function for restoring selections when reselecting.
    void                 restoreSelection(const char *selection_string,
                                          int selector_index);

    GU_SelectionType     getSelectionTypeForCurNode();

    void                 startNonSecureSelector(UI_Event *event);
    void                 undoStartNonSecureSelector();

    void                 finishSelector();

    bool                 isRapidFire() const;

    void                 createHotkeySelector();
    void                 destroyHotkeySelectorIfNeeded();

    void                 handleFinishUndoEvent(UI_Event *event = 0);

    // This class contains information about the input field to which a
    // selector is bound.
    class MSS_API MSS_SelectorBind
    {
    public:
        MSS_SelectorBind()
            : mySelector(0), mySelectorInfo(0)
            { }
        ~MSS_SelectorBind()
            {
                // It's possible that the resource manager doesn't exist
                // if we're being deleted because of an exit callback.
                if( mySelector && PIresourceManagerExists() )
                    BMgetResourceManager()->deleteSelector(
                            (BM_InputSelector *)mySelector);
            }
        OP3D_InputSelector              *mySelector;
        const PI_BindingSelectorInfo    *mySelectorInfo;
    };

    UT_RefArray<MSS_SelectorBind>        mySelectors;   // info about selectors
    OP3D_InputSelector                  *myCurrentSelector;
    const PI_BindingSelectorInfo        *myCurrentSelectorInfo;

    // Selector used for selector hotkeys when in quickselect mode and 
    // secure selection is turned off.
    OP3D_InputSelector                  *myHotkeySelector;
    UI_Menu *                            myHotkeySelectorMenu;

    // The selector index is the index of the current selector in the list of
    // selectors provided for this state.  It coincides with the index into
    // the gdp's set of temporary selections.
    int                                  mySelectorIndex;

    UT_PtrArray<UT_StringArray *>        myReselectPathLists;
    UT_StringArray                       myReselectSelectionStrings;
    UT_RefArray<GU_SelectionType>        myReselectSelectionTypes;

    UI_Value                             mySelFinishedValue;

    float                                mySelectorActiveCoords[2];
    UI_Event                             myRapidFireActiveEvent;
    UI_Value                             myRapidFireActiveEventValue;

    mss_InputSelectorUndoWorker *        mySelectorUndoWorker;

    int                                  mySelectableFlag; // uses selectors?
    unsigned                             myMouseTakenFlag:1; // can rapid-fire?
    bool                                 myFirstSelectionFlag;
    bool                                 myInNonSecureUndo;
    bool                                 myInNonSecureSelector;

    int                                  myDoubleClickUndoLevel;
};

#endif

---