CH/CH_Collection.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:        Channel library (C++)
 *
 * COMMENTS:    Collection for channel library
 *
 */

#ifndef __CH_Collection_h__
#define __CH_Collection_h__

#include "CH_API.h"
#include "CH_EventManager.h"
#include "CH_Manager.h"
#include "CH_ExprLanguage.h"
#include <iostream.h>
#include <SYS/SYS_Types.h>
#include <UT/UT_String.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_SymbolTable.h>
#include <UT/UT_Packet.h>
#include <UT/UT_ThreadSpecificValue.h>
#include <EXPR/EX_Error.h>

class CH_Channel;
class CH_Collection;
class CH_LocalVariable;

class UT_XformOrder;

typedef enum {
    CH_OS,
    CH_CH,
    CH_LT,
    CH_IT,
    CH_OT,
    CH_LIT,
    CH_LOT,
    CH_PREV_IT,
    CH_NEXT_OT,
    CH__SEGP,
    CH__PSEGP,
    CH__NSEGP,
    CH_IV,
    CH_OV,
    CH_IM,
    CH_OM,
    CH_IA,
    CH_OA
} CH_LOCAL_VARIABLE;

enum {
    CH_LOCAL_VARIABLE_TABLE_INDEX = 1
};

// Forward declare of OP_Channels so that we can provide a mechanism to
// cast to it safely.
class OP_Channels;

class CH_API CH_CollectionIterator
{
// Starting at the current input stream position, tries to load
// the information about the next collection from the chn or bchn file
// that the input stream represents.
public:
    CH_CollectionIterator(UT_IStream &is, int binary);
    bool begin(UT_String &path);
    bool end();
    bool nextCollection(UT_String &path);

private:
    UT_IStream *curr_is;
    int is_binary;
};

class CH_API CH_Collection : public UT_SymbolTable
{
public:
             CH_Collection(CH_Manager *manager);
             CH_Collection(CH_Manager *manager, const CH_Collection &from);
    virtual ~CH_Collection();

    SETUPCLASSPACKETID("CH_Collection");

    CH_Manager  *getManager()   const { return myManager; }
    float        getTolerance() const { return myManager->getTolerance(); }

    virtual int  canAccess(uint mask) const;
    virtual int  canAccessChannel(uint mask, const CH_Channel *chp) const;

    //
    // When getting channels, it's the channel name that is passed,
    // NOT the path
    //
    const CH_Channel    *getChannel(const char *name) const;
    CH_Channel          *getChannel(const char *name);
    const CH_Channel    *getChannel(int idx) const { return myChannels(idx); }
    CH_Channel          *getChannel(int idx)       { return myChannels(idx); }
    const CH_Channel    *getChannel(const UT_String &name) const
                         {
                             return getChannel((const char *)name);
                         }
    CH_Channel          *getChannel(const UT_String &name)
                         {
                             return getChannel((const char *)name);
                         }

    int                  getChannels(CH_ChannelList &chans, 
                                     int scope=0) const;

    int                  getChannels(CH_ChannelList &chans,
                                     const char *pattern) const;

    int                  getChannelNames(CH_NameList &list, int scope=0) const;
    int                  getChannelCount(int scoped = 0) const;

    //
    // Get a collection or channel given a relative path from this collection
    //
    virtual CH_Collection       *findCollection(const char *path) const = 0;
    CH_Channel                  *findChannel   (const char *path) const;
    CH_Channel                  *findOrCreateChannel   (const char *path);


    //
    // When adding a channel, adding by name is the safest method since
    //
    CH_Channel          *addChannel(const char *name);
    CH_Channel          *addChannel(CH_Channel *chp);

    CH_Channel          *dupChannel(const char *name);
    virtual CH_Channel  *dupChannel(const CH_Channel &from);

    // The following method will rename a channel.  Only "spare" channels are
    // allowed to be re-named.  The renaming will fail if the channel is not a
    // spare channel, or if the channel isn't found.
    virtual int          rename(const char *from_name, const char *to_name,
                                const char *to_alias);
    virtual int          rename(CH_Channel *from, const char *to_name,
                                const char *to_alias);

    void                 deleteChannel(const char *name);
    void                 deleteChannel(CH_Channel *chp);
    int                  deleteChannels();

    //
    // Methods to get a channel evaluated
    //
    float                evaluate(CH_Channel *chp, float time,
                                  bool no_disabling /*=false*/, int thread);
    void                 evaluate(CH_Channel *chp, float from, float to,
                                  float *vals, int nsamples,
                                  bool no_disabling /*=false*/,
                                  bool use_cache /*=false*/, int thread);
    void                 evaluateString(UT_String &result,
                                        CH_Channel *chp, float time,
                                        int thread);

    //
    // Reparses all the expressions.  Should be done if the local
    // variables have changed.
    //
    void                 unresolveLocalVars(int thread);

    //
    // Now, some common mirrors for system calls
    //
    virtual void         getFullPath(UT_String &path) const = 0;
    void                 getFullPath(const CH_Channel *chp, UT_String &p,
                                     bool use_alias=false) const;

    //
    // channelFind() & collectionFind() will traverse the channel tree
    // for the given path, calling the callback on every match of the
    // specified type.  For example:  /o*/g*/t?
    //
    void                 channelFind(const char *path, CHfindCallBack callback,
                                void *data = 0) const;

    // These methods will do word finding/replacement in all expressions of
    // all channels.
    void                 findString(const char *word, bool fullword,
                                    bool usewildcards, CHfindCallBack callback,
                                    void *data = 0);
    int                  findString(const char *word, bool fullword,
                                    bool usewildcards) const;
    int                  changeString(const char *from, const char *to,
                                      bool fullword, int thread);

    //
    // The following pure virtuals must be defined by a sub-class.
    // These provide the collection name and the channel hierarchy.
    //
    virtual const UT_String     &getName() const = 0;

    virtual int                  getUniqueId() const;
    virtual CH_Collection *      lookupCollection(int id) const;

    virtual const CH_Collection *getParent() const = 0;
    virtual       CH_Collection *getParent() = 0;

    virtual const CH_Collection *getChild(const char *name) const = 0;
    virtual       CH_Collection *getChild(const char *name) = 0;

    //
    //  These methods only get child collections, not channels
    virtual int          getChildren(CH_NameList &names) const =0;
    virtual int          getChildren(CH_CollectionList &grps) const =0;


    virtual void         getVariableValue(int table, int index, UT_String &str,
                                          int thread);
    virtual float        getVariableValue(int table, int index, int thread);
    virtual void        *getVariableData(int table, int index, int thread);

    virtual const CH_LocalVariable *resolveVariable(const char *name, int &tab);

    //
    // I/O methods
    //
    int                  save(ostream &os, int binary, bool compiled, int scope,
                              const CH_ChannelList *channels = NULL) const;
    int                  saveToFile(const char *nm) const;

    bool                 load(UT_IStream &is, const char *path = 0,
                              const CH_LoadInfo *load_info = 0,
                              CH_ChannelList *loadedChannels = 0,
                              bool delete_keys = false);
    int                  loadFromFile(const char *nm);

    //
    //  Keyframe management & convenience function
    //
    float                findKey(float gtime, int dir) const;
    virtual void         saveKeyFrameForUndo(CH_Channel *chp, float gtime) = 0;

    // int                       anyModified() const;
    // void              clearModified();

    int                  getChanged() const { return myModifiedFlag; }
    virtual void         setChanged(CH_CHANGE_TYPE how, void *data=0);

    void                 setExpose( bool onoff );
    bool                 getExpose() const  { return myExpose; }

    //
    // Remove and delete all channels
    //
    void                 clearAndDestroy();

    //
    //  Methods used only in the channel library glue
    //
    float                getGlueIV(int thread) const;
    void                 getGlueTime(float &t, float &t0, float &t1,
                                     float &v0, float &v1, int thread) const;
    void                 getGlueSlope(float *m0, float *m1,
                                      float *a0, float *a1, int thread) const;

    void                 setEvalChannel(CH_Channel *chp, int thraed,
                                        const char *name = NULL);
    void                 setEvalChannel(CH_Channel *chp, const char *name,
                                        CH_Channel *&old_chp,
                                        const char *&old_name,
                                        int thread);
    const CH_Channel    *getEvalChannel(int thread) const
                            { return myThreadSpecificData.getValueForThread(thread).myEvalChannel; }
    CH_Channel          *getEvalChannel(int thread)
                            { return myThreadSpecificData.getValueForThread(thread).myEvalChannel; }
    const char          *getEvalChannelName(int thread) const
                            { return
                                myThreadSpecificData.getValueForThread(thread).myEvalChannelName; }
    void                 getEvalChannelAndName(CH_Channel *&chp,
                                               const char *&name,
                                               int thread) const
                         {myThreadSpecificData.getValueForThread(thread).getEvalChannel(chp,name);}

    void                 initManager(CH_Manager *manager);

    float               getGlobalStart() const          
                        { return myManager->getGlobalStart(); }
    float               getGlobalEnd() const    
                        { return myManager->getGlobalEnd(); }

    // returns the 'range' of the collection - the lowest start time and the
    // highest end time. Returns false if the collection has no 'range'.
    // Single expressions do not set the range, but will set the timedep
    // flag if necessary. The timedep flag is set if even one of the channels
    // is time dependent.
    bool                 getCollectionRange(float &start, float &end,
                                            bool &timedep, int thread);

    void                 addDynamicVariables(CH_LocalVariable *table)
                         { myVariables[3] = table; }


    // This method should only be called by CH_Manager. It signifies
    // this collection is dependent on a param function and will be
    // calledback on modification until removeParamDependency is called.

    void                 addedParamDependency();
    void                 removeParamDependency();

    // Returns the xform order for this collection given a specific channel.
    // This defaults to XYZ, but can be overridden by OP_Node types
    // to handle their specific orders, such as with Objects.
    virtual void         getXformOrder(UT_XformOrder &xord, CH_Channel *chp);

    bool                 getExternal() const
                            { return myExternal; }
    void                 setExternal(bool yesno)
                            { myExternal = yesno; }

    // Set the alias on a channel -- returns true if the alias was 
    // successfully set and false otherwise
    bool                 setChannelAlias(CH_Channel &chp, const char *alias);

    // Returns true if s represents a valid Channel name and false otherwise
    static bool          isValidChannelName(const char *s);

    // Returns a valid pointer if this instance is of an OP_Channel and
    // NULL otherwise.
    virtual OP_Channels *castToOPChannels() { return 0; }
    virtual const OP_Channels   *castToOPChannels() const { return 0; }

    // Overridden by OP_Channels to add dependencies for local variables
    virtual void         addLocalVarDependency(int table, int index,
                                               void *ref_id);

    CH_ExprLanguage      getExprLanguage() const;
    void                 setExprLanguage(CH_ExprLanguage language);
    
protected:
    class CH_API ch_ThreadSpecificData
    {
    public:
        ch_ThreadSpecificData() : myEvalChannel(0), myEvalChannelName(0) {}

        void setEvalChannel(CH_Channel *chp, const char *name = NULL);
        void setEvalChannel(CH_Channel *chp, const char *name,
                            CH_Channel *&old_chp, const char *&old_name)
        {
            getEvalChannel(old_chp, old_name);
            setEvalChannel(chp, name);
        }
        void getEvalChannel(CH_Channel *&chp, const char *&name) const
        {
            chp = myEvalChannel;
            name = myEvalChannelName;
        }

        CH_Channel      *myEvalChannel;         // evaluation channel
        const char      *myEvalChannelName;
    };

    // checkExpressionError() is split up into a checking part and an actual
    // error handling part, evaluationError() so that the checking part can
    // be inlined.
    SYS_FORCE_INLINE void
    checkEvaluationError(const CH_Channel *chp, int thread) const
    {
        int err = ev_GetErrNo(thread);
        if (err != EV_NOERROR)
            evaluationError(chp, err, thread);
    }

    virtual void         addErrorToErrorManager(const char *type, int code,
                                                const char *msg=0) const;

    void                 addLocalVariables(CH_LocalVariable *table)
                         { myVariables[2] = table; }
    const CH_Collection *getRoot() const;
    //
    // Don't publicize our implementation:
    //
    const CH_ChannelList *getChannels() const { return &myChannels; }

    virtual void         notifyChannelRenameDependents(const char *old_name,
                                                       const char *new_name);


    CH_Manager          *myManager;
    CH_LocalVariable    *myVariables[4];        // Local var tables
    CH_ChannelList       myChannels;            // For easy traversal
    UT_ThreadSpecificValue<ch_ThreadSpecificData> myThreadSpecificData;
    UT_SymbolTable       *myChannelAliasesTable;

    int                  myModifiedFlag;        // My modified flag

    CH_ExprLanguage      myExprLanguage;

    char                 myParamDependent;      // relies on param function

    bool                 myExternal;
    bool                 myExpose;

private:
    // evaluationError() generates the appropriate call to opError() and then
    // clears the expression error state.
    void                 evaluationError(const CH_Channel *chp, int err,
                                         int thread) const;

    void                 deleteChannel(unsigned index); // Delete from array
    CH_Channel *         loadChannelRange(UT_IStream &is, const char *name,
                                          const CH_LoadInfo &load_info);

    friend class         CH_Manager;
};

CH_API extern void
CHcollectionsToOPchannels( CH_CollectionList const& collections,
                                UT_PtrArray< OP_Channels* > &op_channels );

#endif

---