CH/CH_Manager.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:
 *      Mark Elendt
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        CH library (C++)
 *
 * COMMENTS:    Manager of all channels for a world.
 *
 */

#ifndef __CH_Manager_h__
#define __CH_Manager_h__

#include "CH_API.h"
#include "CH_KeyState.h"
#include "CH_ChannelRefHashTable.h"
#include "CH_ExprLanguage.h"
#include "CH_Types.h"
#include <iostream.h>
#include <SYS/SYS_Types.h>
#include <UT/UT_Assert.h>
#include <UT/UT_HashTable.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_Math.h>
#include <UT/UT_Floor.h>
#include <UT/UT_String.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_Thread.h>
#include <UT/UT_ThreadSpecificValue.h>

class CH_Collection;
class CH_Channel;
class CH_ChannelRef;
class CH_ExprDefine;
class CH_LocalVariable;
class CH_Group;
class CH_TimeGroup;
class CH_ScriptAccessManager;
class UT_StringArray;
class UT_HashTable;
class UT_WorkBuffer;
class UT_SuperInterval;
class chParamData;


class CH_API CH_LoadInfo
{
public:
    bool    use_load_range;
    float   load_start;
    float   load_end;
    float   file_start;
    float   file_end;
    bool    full_replace;
};

class CH_API CH_Manager
{
public:
    typedef enum {
        //CH_ON_COLLISION_FAIL,
        CH_ON_COLLISION_RENAME,
        CH_ON_COLLISION_MERGE,
        CH_ON_COLLISION_REPLACE,
        CH_ON_COLLISION_ASSERT
    } CollisionBehaviour;

    typedef enum {
        CH_EXPANSION_TYPE_EXPRESSION    = 1,
        CH_EXPANSION_TYPE_VARIABLE      = 1 << 1,
        CH_EXPANSION_TYPE_DEFAULT       = CH_EXPANSION_TYPE_EXPRESSION |
                                          CH_EXPANSION_TYPE_VARIABLE,
    } ExpansionType;

    typedef CollisionBehaviour (*CBCallback)( CH_Group *source,
                                                CH_Group *target );

             CH_Manager(int initTheExpressionLibrary = 1);
    virtual ~CH_Manager();

//  The following method is used to set the context to this manager.
    static CH_Manager   *getContext()
                         {
                            UT_ASSERT( theManager );
                            return theManager;
                         }
    static bool          getContextExists() { return (bool)theManager; }
    virtual void         setContext();

    int                  condenseCommon(UT_String &path);

    void                 resetPlayback();

    void                 resetChannelOptions();
    bool                 loadChannelOptions( const char *filename );
    bool                 saveChannelOptions( const char *filename );

    void                 setDefaultExpression(const char *s)
                            {
                                if( s && *s )
                                    myDefaultExpression.harden( s );
                            }
    const char          *getDefaultExpression() const
                            { return (const char *)myDefaultExpression; }
    void                 setDefaultRotationExpression(const char *s)
                            {
                                if (s)
                                    myDefaultRotationExpression.harden(s);
                            }
    const char          *getDefaultRotationExpression() const
                            { return (const char *)myDefaultRotationExpression;}
    void                 setAutoSlope(bool onoff)
                            { myAutoSlope = onoff; }
    bool                 getAutoSlope() const
                            { return myAutoSlope; }
    void                 setDefaultSlope(float slope)
                            { myDefaultSlope = slope; }
    float                getDefaultSlope() const
                            { return myDefaultSlope; }
    void                 setAutoSplit(bool onoff)
                            { myAutoSplit = onoff; }
    bool                 getAutoSplit() const
                            { return myAutoSplit; }
    void                 setDefaultSplitExpression(const char *expr)
                            { myDefaultSplitExpression.harden(
                                                        expr ? expr : "" ); }
    const char          *getDefaultSplitExpression() const
                            { return (const char *)myDefaultSplitExpression; }

    void                 setHoldLastKey(bool onoff)
                            { myHoldLastKey = onoff; }
    int                  getHoldLastKey() const
                            { return myHoldLastKey; }
    const char          *getChanCreateKeyExpression() const
                            { return (const char *)myChanCreateKeyExpression; }
    void                 setChanCreateKeyExpression(const char *s)
                            { myChanCreateKeyExpression.harden(s ? s : ""); }
    bool                 getAlwaysCommitKeyChange() const
                            { return myAlwaysCommitKey; }
    void                 setAlwaysCommitKeyChange( bool onoff )
                            { myAlwaysCommitKey = onoff; } 
    bool                 getSegCacheStatus() const
                            { return mySegCacheStatus; }
    void                 setSegCacheStatus(bool onoff)
                            { mySegCacheStatus = onoff; }

    //
    // Scoping functions
    //
    void         clearChannelScope();

    // Returns scoped channels only (not scoped parameters)
    void         getScopedChannels(CH_ChannelList &channels, bool sorted=false);

    // Returns count of scoped channels AND scoped parameters
    int          getNumScopedChanRefs() const
                    { return myScopedChannelsTable.entries(); }

    // mask corresponds to flags in CH_ScopeMasks. Use 0 for mask to mean all
    // scoped channel refs.
    // Returns scoped channel AND scoped parameter refs
    void         getScopedChanRefs(CH_ChannelRefList &chanrefs,
                                    unsigned mask = 0,
                                    bool sorted=false) const;
    void         getSelectedScopedChanRefs(CH_ChannelRefList &chanrefs,
                    bool sorted=false, int operateOn=CH_SELECTED);

    // utility functions for getting keyframe numbers:
    // they return array of keyframes in the or scoped channes
    // between minframe and maxframe, indexed relative to the start index
    // The frames are unique and sorted in a ascending order.
    void         getScopedChannelsKeyFrames( UT_IntArray &frames,
                                     int minframe, int maxframe);

    // Useful method to group multiple scope change event notifications
    // together.
    void         blockModifyScope(int on_off);

    // these next two methods can be used to manipulate channel scope state
    // using the full path of the channel.  The correct behaviour will take 
    // place if the channel doesn't yet exist and so forth.
    void         scopeChannel(const CH_ChannelRef &chref, bool on_off);
    void         scopeChannel(const char *full_chan_path, bool on_off);
    bool         scopeChannelInternal(CH_Channel *chp, bool on_off);
    bool         scopeChannelInternal(const CH_ChannelRef &chref, bool on_off);
    void         unscopeChannelsWithNodeId(int node_id, bool force=false);

    // this function should only be used by CH_Channel, CH_Collection, and here
    void         scopeChanged( unsigned flags, bool propagate=true );

    // these functions can be used by anyone
    bool         isChannelScoped(CH_Channel *chp) const;
    bool         isChannelScoped(const char *full_chan_path) const;
    bool         isChannelScoped(const CH_ChannelRef &chref) const;

    //
    // Pending Channels
    //
    void         clearPendingChannels();
    void         getPendingChannels(CH_ChannelList &channels);

    // addPendingChannel is intended to be used by CH_Channel/CH_Collection!
    void         addPendingChannel( CH_Channel *chp );
    void         removePendingChannel( CH_Channel *chp );

    //
    // Displayed Channels (within the scoped channels)
    //
    bool         isChannelDisplayed( const CH_ChannelRef &chref ) const;
    bool         isChannelDisplayed( const char *full_chan_path ) const;
    void         clearDisplayedChannels( bool propagate = true );
    void         displayAllScopedChannels( bool propagate = true );
    void         displaySelectedScopedChannels( bool propagate = true );

    void         displayChannel( const CH_ChannelRef &chref,
                                 bool propagate = true );
    void         displayChannel( const char *full_chan_path,
                                 bool propagate = true );
    void         undisplayChannel( const CH_ChannelRef &chref,
                                   bool propagate = true );
    void         undisplayChannel( const char *full_chan_path,
                                   bool propagate = true );

    //
    // Selected Channels (within the scoped channels)
    //
    bool         isChannelSelected( const CH_ChannelRef &chref ) const;
    bool         isChannelSelected( const char *full_chan_path ) const;
    void         clearSelectedChannels( bool propagate = true );
    void         selectAllScopedChannels(bool propagate = true );

    void         selectChannel( const CH_ChannelRef &chref,
                                bool propagate = true );
    void         selectChannel( const char *full_chan_path,
                                bool propagate = true );
    void         deselectChannel( const CH_ChannelRef &chref,
                                  bool propagate = true );
    void         deselectChannel( const char *full_chan_path,
                                  bool propagate = true );

    //
    // Pinned Channels (within the scoped channels)
    //
    void         togglePinAllScopedChannels();
    void         togglePinScopedChannels( CH_ChannelRefList chanrefs );
    void         pinAllScopedChannels( bool propagate = true );
    void         unpinAllScopedChannels( bool propagate = true );
    void         pinSelectedChannels( bool propagate = true, 
                                        int operateOn = CH_SELECTED );
    void         unpinSelectedChannels( bool propagate = true,
                                        int operateOn = CH_SELECTED );
    void         pinChannels( CH_ChannelRefList chanrefs, 
                                        bool propagate = true );
    void         unpinChannels( CH_ChannelRefList chanrefs,
                                        bool propagate = true );
    //
    // Generic channel flag manipulation methods
    //
    void         setChannelFlags( const CH_ChannelRef &chref,
                                    unsigned flags,
                                    bool on_off,
                                    bool propagate = true );
    unsigned     getChannelFlags( const CH_ChannelRef &chref ) const;

//
//  Expand a string given a specific channel set (for locals).  It's possible
//      that the channel collection can be null, meaning local variables won't
//      be picked up.  The input string is expected to be an unexpanded string
//      value using the old improper expression syntax.
//      The method returns a mask with
//              CH_EXPRTIME set if the string uses time dependent variables.

    int         expandString(const char *string, UT_String &expanded,
                             float time, CH_Collection *local = 0,
                             int thread = 0,
                             int expansion_type = CH_EXPANSION_TYPE_DEFAULT);

    void        buildStringOpDependencies( const char *str, void *ref_id,
                                           CH_Collection *locals, int thread );
    bool        changeStringOpRef( UT_String &str,
                                   const char *new_fullpath,
                                   const char *old_fullpath,
                                   const char *old_cwd,
                                   const char *chan_name,
                                   const char *old_chan_name,
                                   CH_Collection *locals,
                                   int thread );

    // These functions evaluate expressions that have been specified using the
    // old proper expression syntax.
    float       evaluate(const char *expr, float now,
                        CH_Collection *local=0, int *frame_dep=0,
                        int thread = 0,
                        CH_ExprLanguage language=CH_OLD_EXPR_LANGUAGE);
    int         evaluateString(const char *expr, UT_String &result,
                        float now, CH_Collection *local=0,
                        int thread = 0,
                        CH_ExprLanguage language=CH_OLD_EXPR_LANGUAGE);

//
//  Global parameter management
//

    // This function tells us if we are in the process of setting a global
    // param value. This is useful for differentiating between real node
    // change events, and apparent node changes caused by setting a global
    // param.
    // If add_dependencies is set, the currently evaluating operator will have
    // dependencies added for the global parameter.  Disable this if you're
    // just getting values for push/pop of values.
    bool        getIsSettingGlobalParam() const;
    void        setIsSettingGlobalParam(bool val);
    void        getGlobalParamF(const char *token, CH_Collection *scope,
                                fpreal &result, fpreal def, int thread,
                                bool add_dependencies /*=true*/);
    void        getGlobalParamS(const char *token, CH_Collection *scope,
                                UT_String &result, const char *def,
                                int thread, bool add_dependencies /*=true*/);
                            
    int         setGlobalFloatParam(const char *token,
                               float val,
                               CH_Collection *&owner);
    int         setGlobalStringParam(const char *token,
                               const char *strval,
                               CH_Collection *&owner);

    int         removeGlobalParamOwner(CH_Collection *owner);
    void        dumpGlobalParams(ostream &out) const;

    // The optional dependents hash table, if specified, will be populated with
    // hashes (UT_Hash_Ptr) of the dependent CH_Collection(s).
    void        dirtyOrphanGlobalParamDependents(const char *token,
                                                 CH_Collection *scope,
                                                 bool recurse,
                                                 UT_HashTable *dependents);

    // Like global params, simulation guide parameters need a flag so we
    // know not to destroy interests and extra inputs when they are changed.
    bool        getIsSettingGuideParam() const;
    void        setIsSettingGuideParam(bool val);

    static CH_KeyState   getKeyState(float gtime,
                                     const CH_ChannelList &channels,
                                     bool loose=false);

    static void          getUniqueCollections(
                                     const CH_ChannelList &channels,
                                     CH_CollectionList &collections);

//
//  Channel Group Management
//
    // OLD GROUP FUNCTIONS
    // temporarily preserved
    void                 addGroup(CH_Group *group, int doRename=1);     
    void                 renameOpInGroups( const char *full_from,
                                           const char *full_to );
    void                 sortGroups();

    // NEW GROUP FUNCTIONS
    // working functions
    CH_Group            *getTopGroup() const;
    CH_Group            *findGroup(const char *const_path, bool create = false,
                                    CH_Group *head=0);
    void                 findGroups( CH_GroupList &groups,
                                        const char *pattern, bool minimal );
    void                 findChannelsFromGroups( CH_ChannelList &channels,
                                                    const char *pattern );
    void                 findChanRefsFromGroups( CH_ChannelRefList &chanrefs,
                                                    const char *pattern );
    static bool          makeGroupPathValid( UT_String &path );
    static bool          makeGroupNameValid( UT_String &path );

    CH_GroupList         getSelectedGroups();
    CH_Group            *getCurrentGroup();
    void                 updateGroupSelection(const CH_GroupList &groups,
                                                void *by,
                                                bool propagate = true);
    void                 updateGroupSelectionFromScoped(void *by,
                                                bool propagate = true);
    void                 updateCurrentGroup(CH_Group *group,
                                                void *by,
                                                bool propagate = true);
    void                 enforceLeafOnlyChannels(CH_Group *group,
                                                 const char *name="new_group");
    
    // RMB Group functions
    CH_Group            *createGroup(const char *const_path,
                                        bool doRename = true, CH_Group *head=0);
    void                 renameGroup(CH_Group *group, const char *newname);
    void                 deleteGroup(CH_Group *group);

    // RMB Group* functions
    void                 extractGroup( CH_Group *group, CollisionBehaviour cb );
    CH_Group            *collapseGroups( CH_GroupList const& groups,
                                            const char *name );
    void                 collapseChildren( CH_Group *parent );

    // TODO merge selected

    // Group -> Group functions
    void                 copyIntoGroup( CH_Group *source, CH_Group *target,
                                        CollisionBehaviour cb,
                                        const char *new_name = 0 );
    void                 moveIntoGroup( CH_Group *source, CH_Group *target,
                                        CollisionBehaviour cb,
                                        const char *new_name = 0 );
    void                 addToGroup( CH_Group *source, CH_Group *target,
                                        CollisionBehaviour cb );
    void                 mergeWithGroup( CH_Group *source, CH_Group *target,
                                            CollisionBehaviour cb );
    // TODO remove shared channels?
    // TODO replace group?

    // Channels -> Group functions implemented via G -> G
    void                channelCreated( const CH_Channel *chp );
    void                channelDeleted( const CH_Channel *chp );

    // save, load functions
    void                  saveGroup( CH_Group *g, ostream &os, int binary );
    CH_Group             *loadGroup( UT_IStream &is );


    // Returns true if there exists a situation in which the string can
    // be expanded.  Returns false if there is nothing in the string that
    // indicates that it could be expanded.
    static bool          couldExpandString(const char *str);

    // Gets/Sets the default expression language.
    CH_ExprLanguage      getDefaultExprLanguage()
                                { return myDefaultExprLanguage; }
    void                 setDefaultExprLanguage(CH_ExprLanguage language)
                                { myDefaultExprLanguage = language; }

    // internal functions
private:
    void                 handleGroupCollision( CH_Group *new_group,
                                                CH_Group *existing,
                                            CollisionBehaviour cb );
public:

//
//  Time Group Management
//
    void                 timeGroupsChanged();
    void                 addTimeGroup(CH_TimeGroup *group,
                                        bool doRename=true,
                                        bool force=false);      
    void                 destroyTimeGroup(const CH_TimeGroup *group);
    void                 destroyTimeGroup(int i);
    void                 renameTimeGroup(CH_TimeGroup *group, 
                                         const char *newname,
                                         bool force=false);
    int                  getNTimeGroups() const {return myTimeGroups.entries();}
    CH_TimeGroup        *getTimeGroup(int i)       { return myTimeGroups(i); }
    const CH_TimeGroup  *getTimeGroup(int i) const { return myTimeGroups(i); }
    CH_TimeGroup        *getTimeGroup(const char *name);
    const CH_TimeGroup  *getTimeGroup(const char *name) const;
    int                  getTimeGroupIdx( const char *name ) const;

//
//  Utility function to make a floating point number "nice" - i.e. only
//  use N decimal places.  Should only be used for frames/samples (not time).
    static float         niceNumber(float num, int digits=3);

//
//  Utility function to find a frame separation that is an intelligent
//  multiple/subdivision of the current frame rate, close to the
//  initialSep parameter.
    int                  niceFrameSeparation(float initialSep,
                                             int minimumSep = 1) const;

//
//  Stretching collections will stretch every channel of every collection
//      based on the old time passed to us.
//      The channels will be stretched to fit the new time
    void        stretchCollections(CH_Collection *from, float ostart,
                                        float oend);

    static float getDefaultFPS();
    static float getDefaultLength(float fps);
    static float getDefaultLengthFrames(float fps);

    float       getNumSamples() const           { return mySampleCount; }
    void        setRawNumSamples(int n);
    float       getSamplesPerSec() const        { return myFPS; }
    void        setSamplesPerSec(float fps);
    float       getSecsPerSample() const        { return 1.0 / myFPS; }
    void        setRawSamplesPerSec(float fps);

    float       getGlobalStart() const          { return myStart; }
    float       getGlobalEnd() const            { return myEnd; }
    int         getGlobalStartFrame() const
                { return getFrame( myStart ); }
    int         getGlobalEndFrame() const
                { return getFrame( myEnd ); }
    
    void        setGlobalTime(float start, float end);

    void        setRawInterpolation(int state)  { myRawInterpFlag = state; }
    int         getRawInterpolation()           { return myRawInterpFlag; }

    // CONVERSION
    float       getTolerance() const { return myTimeTolerance; }
    // sample -> time
    float       getTime(float sample) const
                {
                    return ((sample-1.0f)/myFPS);
                }
    // time -> sample (for calculation)
    float       getSampleRaw(float t) const
                {
                    return t*myFPS+1.0f;
                }
    // time -> sample (for display)
    float       getSample(float t) const
                {
                    return niceNumber(getSampleRaw(t));
                }
    // time -> sample (integer)
    int         getFrame(float t) const
                {
                    return (int)SYSfloor(getSampleRaw(t+getTolerance()));
                }
    // sample-delta -> time-delta
    float       getTimeDelta(float sample_delta) const
                {
                    return sample_delta/myFPS;
                }
    // time-delta -> sample-delta
    float       getSampleDelta(float time_delta) const
                {
                    return time_delta*myFPS;
                }
    // time -> time (snapped to an integer frame)
    float       getSnapToFrameTime( float t ) const
                {
                    return getTime( SYSrint( getSampleRaw(t) ) );
                }

    // frame -> frame (snapped to an integer frame)
    float       getSnapSample(float frame) const
                {
                    return SYSrint(frame);
                }
    // say you have a key at frame 0.6 (base_time) and you are moving it with
    // snap to frame on, so you want to snap the amount you move the key so that
    // the key lands on the nearest frame.  In this example, time_delta would be
    // rounded to numbers like: -1.6, -0.6, 0.4, 1.4. This function does this.
    // Note that the parameters and return value are in time not frames as they
    // were in the example.
    float       getSnapToFrameDelta( float base_time, float time_delta ) const;
    // time -> bool (true if time is at an integer frame boundary)
    bool        getIsAtFrame( float t ) const
                {
                    float       snaptime;

                    snaptime = getSnapToFrameTime( t );
                    return UTisEqual(t, snaptime, getTolerance());
                }
    
    // ---
    void        getTimeCode(char *buf, float t);        // Get code in buf
    int         setTimeCode(const char *buf, float &t); // Return time from buf
    void        setTimeCodeOffset(float t)       { myTimeCodeOffset = t; }
    float       getTimeCodeOffset(float ) const { return myTimeCodeOffset; }

    int         getIntegerFrameFlag() const     { return myIntegerFrames; }
    void        setIntegerFrameFlag(int flag)   { myIntegerFrames = flag; }

    int         getRestrictRangeFlag() const    { return myRestrictRange; }
    void        setRestrictRangeFlag(int flag)  { myRestrictRange = flag; }

    int         getShowRangeFlag() const        { return myShowRange; }
    void        setShowRangeFlag(int flag)      { myShowRange = flag; }

    int         getShowTicksFlag() const        { return myShowTicks; }
    void        setShowTicksFlag(int flag)      { myShowTicks = flag; }

    int         getShowAudioFlag() const        { return myShowAudio; }
    void        setShowAudioFlag(int flag)      { myShowAudio = flag; }

    int         getShowKeysFlag() const         { return myShowKeys; }
    void        setShowKeysFlag(int flag)       { myShowKeys = flag; }

    float       getAudioLevel() const           { return myAudioLevel; }
    void        setAudioLevel(float lvl)        { myAudioLevel = lvl; }

    float       getUnitLength() const           { return myUnitLength; }
    void        setUnitLength(float unitlength) { myUnitLength = unitlength; }
    float       getUnitMass() const             { return myUnitMass; }
    void        setUnitMass(float unitmass)     { myUnitMass = unitmass; }
    void        parseUnitsString(const char *units,
                                 fpreal &distexp,
                                 fpreal &massexp) const;
    fpreal      scaleToMKS(const char *fromunits) const;
    fpreal      scaleFromMKS(const char *tounits) const;

    int         getRealTimeFlag() const         { return myRealTimePlay; }
    void        setRealTimeFlag(int flag)       { myRealTimePlay = flag; }
    float       getRealTimeFactor() const       { return myRealTimeFactor; }
    void        setRealTimeFactor(float f)      { myRealTimeFactor = f; }
    bool        getRealTimeDisableSkip() const { return myRealTimeDisableSkip; }
    void        setRealTimeDisableSkip(bool b) { myRealTimeDisableSkip = b; }
    float       getSampleStep() const           { return mySampleStep; }
    void        setSampleStep(float s)          { mySampleStep = s; }

    void        getSampleRange(float &start, float &end)
                {
                    start = myRangeStart;
                    end   = myRangeEnd;
                }
    void        setSampleRange(float start, float end)
                {
                    if (start > end) { myRangeEnd = start; myRangeStart = end; }
                    else             { myRangeEnd = end; myRangeStart = start; }
                }

    int         getHoldFlag() const     { return myHoldFlag; }
    void        setHoldFlag( int flag ) { myHoldFlag = flag; }

//  I/O methods
    int         saveChannels(const char *filename, bool binary, bool compiled,
                             const CH_ChannelList &channels, 
                             bool displayed = false) const;
    int         loadChannels(const char *filename,
                             const char *src_pattern,
                             const char *dest_pattern,
                             bool use_range,
                             const float *tstart,
                             const float *tend,
                             CH_CollectionList &parents,
                             bool delete_keys = false,
                             CH_ChannelRefList *displayed_parms = NULL);
    static bool readCHNFileHeader(UT_IStream &is, bool quiet,
                                  float &version, int &binary,
                                  float &tstart, float &tend);
    static bool skipCHNFileHeaderForCollection(UT_IStream &is);
    static bool getFileType( const char *filename, int &raw, int &binary );
    static bool printFileInfo( ostream &os, const char *filename,
                               CH_Collection *load_coll );

//
//  Expression glue.  Only call this if you know what you're really doing.
    void         addExpressionDefine(CH_ExprDefine *def);

//
//  The following method should only be called by CH_Collection, so please
//  don't mess me up.
    void                 setEvalCollection(CH_Collection *g, int thread)
                            {
                                // We use thread-local storage for the eval
                                // collection.  This isn't because two
                                // different collections can be evaluating
                                // paramaters in different threads at the same
                                // time, though it would be nice for that to be
                                // possible one day.  Instead, it's so that if
                                // Houdini is evaluating a parameter at the
                                // same time as a python script is running code
                                // that checks for the currently evaluating
                                // parameter (so it can add the appropriate
                                // parm interests), that we don't add parm
                                // interests when we shouldn't.
                                myEvalCollection.getValueForThread(thread) = g;
                            }
    CH_Collection       *getEvalCollection(int thread) const
                            {
                                // We use thread-local storage the eval
                                // collection.
                                //
                                // If this is the first time this thread has
                                // accessed the pointer it will be null.
                                // That's exactly the behaviour we want.
                                return myEvalCollection.getValueForThread(
                                                                        thread);
                            }

//
//  The CH_Manager needs a pointer to the channel collection for the
//  OP_Director. This is used to trigger events when channel and time
//  groups are modified.
//
    void                 setRootCollection(CH_Collection *root)
                         {
                             myRootCollection = root;
                         }
    CH_Collection       *getRootCollection() const { return myRootCollection; }

    virtual CH_ScriptAccessManager *getAccessManager(int /*thread*/) { return 0; }

//
//  These methods are usually only used by CH_Collection to evaluate
//      variables belonging to me...
    CH_LocalVariable    *getLocalVariableTable() const;
    void                 getVariableValue(int i, UT_String &str, int thread) const;
    float                getVariableValue(int i, int thread) const;
    void                *getVariableData(int i) const;

    // Should only be called if the variable is flagged as having a
    // CH_VARIABLE_INTVAL.
    int                  getIntegerVariableValue(int i, int thread) const;

    /// Functions for obtaining and setting the current evaluation time
    // @{
    fpreal64             getEvaluateTime(int thread) const
                            { return myEvalTime.getValueForThread(thread); }
    void                 setEvaluateTime(float time, int thread)
                            { myEvalTime.getValueForThread(thread) = time; }
    // @}

    /// The following function only remains for backwards compatibility of
    /// HDK users. Calls to this function should be replaced with one of the
    /// following forms:
    ///    getEvaluateTime(context.getThread()) -> inside cooking code path
    ///    getEvaluateTime(thread)              -> in expression functions
    ///    CHgetEvalTime()                      -> else without thread variable
    SYS_DEPRECATED fpreal64 getEvaluateTime() const
                                { return getEvaluateTime(UTgetSTID()); }

    // getVariableString should really be protected, but can't do it.
    virtual bool         getVariableString(const char *name,
                                           UT_String &value,
                                           int &timeDepend,
                                           int thread);

    static void          lookupVariable(const char *name, UT_String &val,
                                        int thread);
    static void          lookupVariableNoThread(const char *name,
                                                UT_String &val);
    static void          lookupExpression(const char *name, UT_String &val,
                                          int thread);
    static void          lookupExpressionNoThread(const char *name,
                                                  UT_String &val);
    
    // This should only be called by CH_Collection
    void                 removeParamDependency(CH_Collection *coll);


    /// Use this method to translate a channel reference to a channel pointer.
    /// May return NULL if the channel reference does not reference a valid
    /// channel.
    virtual CH_Channel  *getChRefChannel(const CH_ChannelRef &r) const;

    /// Use this method to determine if the owner of the channel reference
    /// is exposed or not.
    virtual bool         isOwnerExposed(const CH_ChannelRef &r) const;

    /// Use this method to build a channel reference from a channel pointer.
    virtual bool         buildChanRef(CH_ChannelRef &r,
                                               const CH_Channel *chp) const;

    /// Use this method to build a channel reference from a channel path.
    virtual bool         buildChanRef(CH_ChannelRef &r,
                                               const char *path) const;

    bool                 buildChannelRefs( CH_ChannelRefList &reflist,
                                            const CH_ChannelList &chlist );

    bool                 buildChannelRefs( CH_ChannelRefList &reflist,
                                            const UT_StringArray &chlist );

    /// Returns 0 if r1 and r2 are equal, returns -1 if r1 < r2 and 
    /// returns 1 if r1 > r2.
    virtual int          compareChanRefs(const CH_ChannelRef &r1,
                                                 const CH_ChannelRef &r2) const;

    /// Use this method to get the full path of the channel referenced by r.
    virtual void         getChanRefPath(const CH_ChannelRef &r,
                                                 UT_String &path,
                                                 bool use_alias=false) const;

    void                 changeReferencesToNodeId(int old_id, int new_id);
    /// This method will remove all references that this manager knows about
    /// channels belonging to node 'node_id'.  After this method, scoped
    /// channels belonging to node_id will be removed, as will such channels
    /// in channel groups.
    void                 removeReferencesToNodeId(int node_id);

    void                 displayScope() const;

    //
    // Animation functions.
    //
    float                evalBezierFunc(int thread);
    float                evalConstantFunc(int thread);
    float                evalCubicFunc(int thread);
    float                evalCycleFunc(float start_frame, float end_frame,
                                        int thread);
    float                evalCycletFunc(float start_frame, float end_frame,
                                        int thread);
    float                evalEaseFunc(int thread);
    float                evalEaseinFunc(int thread);
    float                evalEaseinpFunc(float ease_speed, int thread);
    float                evalEaseoutFunc(int thread);
    float                evalEaseoutpFunc(float ease_speed, int thread);
    float                evalEasepFunc(float ease_speed, int thread);
    float                evalLinearFunc(int thread);
    float                evalMatchFunc(int thread);
    float                evalMatchinFunc(int thread);
    float                evalMatchoutFunc(int thread);
    float                evalQcubicFunc(int thread);
    float                evalQlinearFunc(int thread);
    float                evalQuinticFunc(int thread);
    float                evalRepeatFunc(float start_frame, float end_frame,
                                        int thread);
    float                evalRepeattFunc(float start_frame, float end_frame,
                                        int thread);
    float                evalSplineFunc(int thread);
    float                evalVmatchFunc(int thread);
    float                evalVmatchinFunc(int thread);
    float                evalVmatchoutFunc(int thread);

protected:
    void                 initExpressionLibrary();

//  Since this is possibly a base class, the library glue initialization has
//      to be done after the construction
    void                 initLibraryGlue();

private:
    int                  internalSetGlobalParam(const char *token,
                                float val, const char *strval,
                                CH_Collection *&owner);
    int                  internalSetGlobalParam(const char *token,
                                float val, const char *strvel,
                                CH_Collection *&owner, CH_Collection *scope);
    void                 internalDirtyOrphanGlobalParamDependents(
                                const char *token, CH_Collection *scope,
                                UT_HashTable *dependents);
    void                 stretchCollection(CH_Collection *grp,
                                           float os, float ns, float stretch);
    static char         *chExprExpander(const char *str, int thread);

    UT_ThreadSpecificValue<CH_Collection *> myEvalCollection;
    UT_ThreadSpecificValue<fpreal64>        myEvalTime;

    CH_Group                    *myTopGroup;
    UT_StringArray               mySelectedGroupPaths;
    UT_String                    myCurrentGroupPath;
    UT_PtrArray<CH_TimeGroup *>  myTimeGroups;
    CH_Collection               *myRootCollection;
    float                        mySampleCount;
    float                        myFPS;
    float                        myStart, myEnd;

    float                        myRangeStart;
    float                        myRangeEnd;
    float                        myRealTimeFactor;
    float                        mySampleStep;
    float                        myTimeTolerance;
    float                        myTimeCodeOffset;

    chParamData                 *findGlobalParam(const char *token,
                                                 CH_Collection *scope);
    chParamData                 *findOrCreateGlobalParam(
                                        const char *token, CH_Collection *scope,
                                        fpreal fval, const char *sval);
    UT_HashTable                *myGlobalParams;
    chParamData                 *myLastGlobalParam;
    bool                         mySettingGlobalParam;

    bool                         mySettingGuideParam;

    unsigned                     myGroupsSorted:1,
                                 myIntegerFrames:1,
                                 myRealTimePlay:1,
                                 myRealTimeDisableSkip:1,
                                 myHoldFlag:1,
                                 myRestrictRange:1,
                                 myShowRange:1,
                                 myShowTicks:1,
                                 myShowAudio:1, 
                                 myShowKeys:1;

    short                        myRawInterpFlag;

    UT_String           myDefaultExpression;
    UT_String           myDefaultRotationExpression;
    bool                myAutoSplit;
    UT_String           myDefaultSplitExpression;
    bool                myAutoSlope;
    float               myDefaultSlope;
    bool                myHoldLastKey;
    bool                myAlwaysCommitKey; // auto-commit value change on keyfrm
    bool                mySegCacheStatus;
    UT_String           myChanCreateKeyExpression;
    float               myAudioLevel;
    float               myUnitLength;
    float               myUnitMass;

    CH_ChannelRefHashTable      myScopedChannelsTable;
    CH_ChannelList              mySortedScopedChannels;
    bool                        myScopedChannelsSorted;
    UT_HashTable                myPendingChannelsTable;

    CH_ExprLanguage             myDefaultExprLanguage;

    int                         myBlockModifyScope;
    unsigned                    myPendingScopeChange;

    static CH_Manager           *theManager;
};

CH_API void CHsortChannels( CH_ChannelList &channels );
CH_API void CHsortChannelRefs( CH_ChannelRefList &channels );
CH_API void CHsortChannelPaths( UT_StringArray &channel_paths );

CH_API void CHchannelsToCollections( CH_ChannelList const& channels,
                                     CH_CollectionList &collections );

inline
CH_Manager *CHgetManager()
{
    return CH_Manager::getContext();
}

inline float CHgetEvalTime()
{
    return CH_Manager::getContext()->getEvaluateTime(UTgetSTID());
}

CH_API extern float       CHgetTimeFromFrame( float frame );
CH_API extern int         CHgetFrameFromTime( float time );
CH_API extern float       CHgetSampleFromTime( float time );
CH_API extern void        CHbuildRange(int start, int end, UT_SuperInterval &r);

/// The CHoutputChannelList functions output a formatted string 
/// representing the given channels.  One version of the function takes a 
/// list of channels while the other takes a string array of full paths
/// to channels.  The given arrays may be modified (they might need sorting).
CH_API extern void        CHoutputChannelList(UT_WorkBuffer &info,
                                              CH_ChannelList &channels);
CH_API extern void        CHoutputChannelList(UT_WorkBuffer &info,
                                              UT_StringArray &channel_paths);

CH_API extern void        CHdisplayFlags( unsigned flags, ostream &s );

#endif

---