OP_NodeFlags.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:        OP Library (C++)
 *
 */

#ifndef __OP_NodeFlags_h__
#define __OP_NodeFlags_h__

#include "OP_API.h"
#include <SYS/SYS_Types.h>
#include <iosfwd>

class UT_IStream;
class UT_String;
class OP_Node;
class OP_Network;
class OP_Director;

#define OP_BYPASS_FLAG          'b'
#define OP_COLORDEFAULT_FLAG    'F'
#define OP_COMPRESS_FLAG        'c'
#define OP_CURRENT_FLAG         'C'
#define OP_DISPLAY_FLAG         'd'
#define OP_EXPOSE_FLAG          'e'
#define OP_FOOTPRINT_FLAG       'f'
#define OP_HIGHLIGHT_FLAG       'h'
#define OP_LOCK_FLAG            'l'
#define OP_SOFT_LOCK_FLAG       'K'
// Export is implemented in CHOP & COP, CHOP_EXPORT_FLAG aliases this.
#define OP_EXPORT_FLAG          'o'
#define OP_OUTPUTFORVIEW_FLAG   'O'
#define OP_PICK_FLAG            'p'
#define OP_DESCRIPTIVENAME_FLAG 'P'
#define OP_DISPLAYCOMMENT_FLAG  'Y'
#define OP_RENDER_FLAG          'r'
#define OP_SAVEDATA_FLAG        's'
#define OP_TEMPLATE_FLAG        't'
#define OP_UNLOAD_FLAG          'u'
#define OP_VISIBLE_FLAG         'V'
#define OP_XRAY_FLAG            'y'

#define OP_MODELED_FLAG         'm'
#define OP_END_FLAG             'E'
#define OP_ORIGIN_FLAG          'x'

#define OP_FLAG_ON              " on"
#define OP_FLAG_OFF             " off"

#define SET_FLAG_STRING(str_val, flag_val)      \
            str_val = (flag_val) ? OP_FLAG_ON : OP_FLAG_OFF

//___________________________________________________________________________

class OP_API OP_NodeFlags
{
public:
    
    enum OP_LockTypes : char
    { 
        OP_UNLOCKED     = 0x0, 
        OP_HARD_LOCKED  = 0x1, 
        OP_SOFT_LOCKED  = 0x2
    };

    static const char  *getFlagName(uchar token);

    static const uchar *getTakeFlagTokens();
    static bool         isTakeFlag(uchar token);

    // Methods to check whether a particular flag is subject to permissions.
    // The set of flags subject to asset permissions is a superset of those
    // subject to standard permissions.
    static bool         isSubjectToStdPermissions(uchar token);
    static bool         isSubjectToAssetPermissions(uchar token);

    void                setRecursion(bool val) const
                        { myRecursion = val; }
    bool                getRecursion() const
                        { return myRecursion; }

    void                setUndoComment(bool on_off)
                        { myUndoComment = on_off; }
    void                setUndoInput(bool on_off)
                        { myUndoInput = on_off; }
    void                setUndoLayout(bool on_off)
                        { myUndoLayout = on_off; }
    void                setUndoDelScript(bool on_off)
                        { myUndoDelScript = on_off; }
    void                setUndoPreTransform(bool on_off)
                        { myUndoPreTransform = on_off; }
    void                setUndoFlagChange(bool on_off)
                        { myUndoFlagChange = on_off; }
    void                setColorDefault(bool on_off)
                        { myColorDefault = on_off; }
    void                setCompress(bool on_off)
                        { myCompress = on_off; }
    void                setDisplayDescriptiveName(bool on_off)
                        { myDisplayDescriptiveName = on_off; }
    void                setDisplayComment(bool on_off)
                        { myDisplayComment = on_off; }
    void                setAlwaysCook(bool on_off)
                        { myAlwaysCook = on_off; }
    void                setUnload(bool on_off)
                        { myUnload = on_off; }
    void                setForceCook(bool on_off)
                        { myForceCook = on_off; }
    void                setHasCookedData(bool on_off)
                        { myHasCookedData = on_off; }
    void                setTimeDep(bool on_off)
                        { myTimeDep = on_off; }
    void                setCooking(bool on_off)
                        { myCooking = on_off; }
    void                setDisplay(bool on_off)
                        { myDisplay = on_off; }
    void                setRender(bool on_off)
                        { myRender = on_off; }
    void                setHighlight(bool on_off)
                        { myHighlight = on_off; }
    void                setTemplate(bool on_off)
                        { myTemplate = on_off; }
    void                setFootprint(bool on_off)
                        { myFootprint = on_off; }
    void                setXray(bool on_off)
                        { myXray = on_off; }
    void                setBypass(bool on_off)
                        { myBypass = on_off; }
    void                setPicked(bool on_off)
                        { myPicked = on_off; }
    void                setEditPicked(bool on_off)
                        { myEditPicked = on_off; }
    void                setHardLocked(bool on_off)
                        { myLockState = on_off ? OP_HARD_LOCKED : OP_UNLOCKED; }
    void                setSoftLocked(bool on_off)
                        { myLockState = on_off ? OP_SOFT_LOCKED : OP_UNLOCKED; }
    void                setLockState(OP_LockTypes state)
                        { myLockState = state; }
    void                setModified(bool on_off)
                        { myModified = on_off; }
    void                setExpose(bool on_off)
                        { myExpose = on_off; }
    void                setSaveBypass(bool on_off)
                        { mySaveBypass = on_off; }
    void                setSaveData(bool on_off)
                        { mySaveData = on_off; }
    void                setOutputForView(int8 output)
                        { myOutputForView = output; }

    // Used to detect if we need to call OP_Node::handleTimeInterest() on
    // a time change
    void                setTimeInterest(bool on_off)
                        { myTimeInterest = on_off; }
    void                setTimeInterestCook(bool on_off)
                        { myTimeInterestCook = on_off; }
    void                setClearDependency(bool on_off)
                        { myClearDependency = on_off; }

    bool                getUndoComment() const
                        { return myUndoComment; }
    bool                getUndoInput() const
                        { return myUndoInput; }
    bool                getUndoLayout() const
                        { return myUndoLayout; }
    bool                getUndoDelScript() const
                        { return myUndoDelScript; }
    bool                getUndoPreTransform() const
                        { return myUndoPreTransform; }
    bool                getUndoFlagChange() const
                        { return myUndoFlagChange; }
    bool                getColorDefault() const
                        { return myColorDefault; }
    bool                getCompress() const
                        { return myCompress; }
    bool                getDisplayDescriptiveName() const
                        { return myDisplayDescriptiveName; }
    bool                getDisplayComment() const
                        { return myDisplayComment; }
    bool                getAlwaysCook() const
                        { return myAlwaysCook; }
    bool                getUnload() const
                        { return myUnload; }
    bool                getForceCook() const
                        { return myForceCook; }
    bool                getHasCookedData() const
                        { return myHasCookedData; }
    bool                getTimeDep() const
                        { return myTimeDep; }
    bool                getCooking() const
                        { return myCooking; }
    bool                getDisplay() const
                        { return myDisplay; }
    bool                getRender() const
                        { return myRender; }
    bool                getHighlight() const
                        { return myHighlight; }
    bool                getTemplate() const
                        { return myTemplate; }
    bool                getFootprint() const
                        { return myFootprint; }
    bool                getXray() const
                        { return myXray; }
    bool                getBypass() const
                        { return myBypass; }
    bool                getPicked() const
                        { return myPicked; }
    bool                getEditPicked() const
                        { return myEditPicked; }
    bool                getHardLocked() const   
                        { return myLockState == OP_HARD_LOCKED; }
    bool                getSoftLocked() const   
                        { return myLockState == OP_SOFT_LOCKED; }
    bool                isLocked() const
                        { return myLockState != OP_UNLOCKED; }
    OP_LockTypes        getLockState() const
                        { return myLockState; }
    bool                getModified() const
                        { return myModified; }
    bool                getExpose() const
                        { return myExpose; }
    bool                getSaveBypass() const
                        { return mySaveBypass; }
    bool                getSaveData() const
                        { return mySaveData; }
    bool                getTimeInterest() const
                        { return myTimeInterest; }
    bool                getTimeInterestCook() const
                        { return myTimeInterestCook; }
    bool                getClearDependency() const
                        { return myClearDependency; }
    int8                getOutputForView() const
                        { return myOutputForView; }

    void                clearAllTakeFlags();
    // Set the activation flag
    void                setTakeFlag(uchar which, bool v);
    bool                getTakeFlag(uchar which) const;
    // Set the actual flag associated with the take token
    void                setTakeValue(uchar which, bool v);
    bool                getTakeValue(uchar which) const;

    void                setHasTakeData(bool on_off)
                        { myHasTakeData = on_off; }
    bool                getHasTakeData() const
                        { return myHasTakeData; }

    bool                getTakeDisplay() const
                        { return myTakeDisplay; }
    bool                getTakeRender() const
                        { return myTakeRender; }
    bool                getTakeTemplate() const
                        { return myTakeTemplate; }
    bool                getTakeExpose() const
                        { return myTakeExpose; }
    bool                getTakeBypass() const
                        { return myTakeBypass; }
    bool                getTakePick() const
                        { return myTakePick; }
    bool                getTakeCurrent() const
                        { return myTakeCurrent; }

    bool                getInterrupted() const
                        { return myInterrupted; }
    void                setInterrupted(bool f)
                        { myInterrupted = f; }
    bool                getDescendantInterrupted() const
                        { return myDescendantInterrupted; }
    void                setDescendantInterrupted(bool f)
                        { myDescendantInterrupted = f; }
    bool                getClearingInterrupt() const
                        { return myClearingInterrupt; }
    void                setClearingInterrupt(bool f)
                        { myClearingInterrupt = f; }

    const char          *getExtra() const
                         { return myExtra; }

    void                 setExtra(const char *opts, int val,
                                  const char **labels)
                         {
                             myExtra = opts;
                             myExtraVal = val;
                             myExtraLabel = labels;
                         }

    bool                 getExtraVal(char a) const;
    void                 setExtraVal(char a, bool on_off);


    void                 appendCommandString(std::ostream &os,
                                             const char *flags,
                                             bool save_to_hip) const;
    void                 getFlagOptions(UT_String &options) const;

    bool                 getLastTimeDep() const
                         { return myLastTimeDep;}
    void                 setLastTimeDep()
                         { myLastTimeDep = myTimeDep;}

    //  Data for the flags
    //
private:
    // the most common bits are promoted to full bool's for
    // maximum on/off testing efficiency
    bool    myModified;         // Changed since load/startup.
    bool    myTimeDep;          // Needs to recook at different time
    bool    myCooking;          // OP is currently cooking
    OP_LockTypes myLockState;   // OP is hard or soft locked
    bool    myForceCook;        // Force op to recook
    bool    myAlwaysCook;       // Always cook this op
    bool    myBypass;           // OP is bypassed when cooking
    bool    myRender;           // OP is rendered
    bool    myDisplay;          // OP is displayed
    bool    myTemplate;         // Data on for display only
    int8    myOutputForView;    // Which output to view

    // USING THESE DIRECTLY IS DEPRECATED! USE THE ACCESSORS!
    bool    mySaveBypass:1,     // OP is bypassed when saving.
            mySaveData:1,       // Save cooked data in file.
            myPicked:1,         // Picked by user.
            myEditPicked:1,     // Picked by user from viewport.
            myUnload:1,         // Unload data after usage.
            myColorDefault:1,   // Use the default color for this node type.
            myCompress:1,       // Display OP node in a compressed UI.
            myDisplayDescriptiveName:1, // Display the descriptive name, if any.
            myDisplayComment:1, // Display the comment, if any.

                // These flags are used to save whether a particular
                // type of change for the node has been saved.
            myUndoParmChange:1, // NB: This flag seems to be no longer used!
            myUndoFlagChange:1,
            myUndoLayout:1,
            myUndoInput:1,
            myUndoComment:1,
            myExpose:1;


private:
    // the most common bits are promoted to full characters for
    // maximum on/off testing efficiency
    mutable bool myRecursion;
    bool        myHasCookedData;        // Node has some concept of cooked data
    bool        myHighlight;            // OP's contents are highlighted

    // Which flags are active in the current take
    bool        myHasTakeData:1,        // Node has take data of some kind
                myTakeDisplay:1,
                myTakeRender:1,
                myTakeTemplate:1,
                myTakeExpose:1,
                myTakeBypass:1,
                myTakePick:1,
                myTakeCurrent:1;

                // When an OP's cooking is interrupted, we set this flag
    bool        myInterrupted:1;
                // Parent networks of any interrupted node has this flag set
    bool        myDescendantInterrupted:1;
                // This one says we are in the clearInterrupt function.
    bool        myClearingInterrupt:1;

    bool        myFootprint:1,
                myXray:1,
                // Used to save whether a particular type of change has been
                // saved
                myUndoDelScript:1,
                myUndoPreTransform:1,
                // Used to detect if we need to call
                // OP_Node::handleTimeInterest() on a time change
                myTimeInterest:1,
                myTimeInterestCook:1, // if we've already checked myTimeInterest
                myClearDependency:1;  // if we should clear cook dependencies

private:
    friend class        OP_Node;
    friend class        OP_UndoFlag;

                        OP_NodeFlags()
                            : myExtra(nullptr),
                              myExtraLabel(nullptr)
                        { setDefaults(); }
                        OP_NodeFlags(const OP_NodeFlags &source)
                        { shallowCopy(source); }

    OP_NodeFlags &      operator=(const OP_NodeFlags &) = delete;

    void                shallowCopy(const OP_NodeFlags &source);


    // Methods to load & save for streams
    void                save(std::ostream &os,
                             bool binary = false,
                             bool forundo = false);
    bool                load(UT_IStream &os, const char *path = nullptr);

    bool                loadAsciiFlag(const char *name, const char *val);
    bool                loadBinaryFlag(int tag, int val);

    // This method initializes all the flags to their default values
    void                setDefaults();

    const char           *myExtra;
    const char          **myExtraLabel;
    unsigned int          myExtraVal;

    bool    myLastTimeDep; // More stable version of myTimeDep that is only
                           // modified after cooking is done.
};

//
// When OP_FLAG_CHANGED events are sent a pointer to this structure
// is given.
struct OP_API OP_NodeFlagData
{
    OP_NodeFlagData(int f, int v) { flag = f; value = v; }
    OP_NodeFlagData() { flag = -1; value = 0; }

    int         flag;           // OP_FOO_FLAG or -1 for all
    int         value;          // New value where appropriate.
};

#endif