OP/OR_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:
 *      Rob Bairos,
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        OR_Manager.h ( OP Library, C++)
 *
 * COMMENTS:
 *
 *      manager to update/remove/add parameter override data
 */

#ifndef __OR_Manager__
#define __OR_Manager__

#include "OP_API.h"
#include <UT/UT_PtrArray.h>
#include <UT/UT_IntArray.h>
#include "OP_Node.h"

class PRM_Parm;
class orData;
class CL_Clip;
class CH_Collection;
class OR_Mapping;

//
// This class is used to minimize string parsing and node globbing
//

class OP_API orPath
{

public:

     orPath(OP_Node *src);
    ~orPath();

    void        setExport(const UT_String &xport);
    int         globNodes(OP_NodeList &globbed);
    void        forceDirty() { myDirty = 1; }

private:

    void        reset();

    UT_String             myExport;
    OP_Node              *mySource;
    int                   myDirty;
    int                   myArgc;
    char                **myArgv;
    int                   myArgvSize;
};


class OP_API orUnit
{
public:

    OP_Node             *myDestOp;
    int                  myTrackIndex;
    int                  myParmIndex;
    int                  myVecIndex;
    const CL_Track      *myEnableTrack;
};


///// an exported data unit


class OP_API orData
{
public:
    OP_Node             *dest;
    int                  parm_idx;
    int                  vec_idx;
    OP_Node             *source;
    OP_Node             *conflict;
    int                  track_idx;
    int                  used;
    int                  current;
    const CL_Track      *enable_track;
};

typedef UT_PtrArray<orUnit *>           orUnitList;

class OP_API OR_Manager
{

public:

     OR_Manager();
    ~OR_Manager();

    int                  getConflicts(const OP_Node *src, OP_NodeList &list);
    const OP_Node       *getFirstConflict(const OP_Node *src);

    void                 removeDestination(OP_Node *dest);
    void                 removeDestination(OP_Node *dest, int parm_idx);

    bool                 findDestination(UT_String &result,
                                         const OP_Node *, int idx)const;

    void                removeSource(OP_Node *src,
                                     OP_NodeList &affected,
                                     UT_IntArray &indices,
                                     int previous);

    int                  override(OP_Node *src, const CL_Clip *clip,
                                  const UT_String &export_path, 
                                  OP_NodeList &affected,
                                  UT_IntArray &indices,
                                  orPath &pathparm,
                                  OR_Mapping *mapping);

    void                 override(OP_Node *src, const CL_Clip *clip,
                                  const orUnitList &units,
                                  OP_NodeList &affected,
                                  UT_IntArray &indices,
                                  orPath &pathparm,
                                  OR_Mapping *mapping);
    
    /// Copy the channel collection corresponding to the given clip to the
    /// export destination.
    int                  copy(OP_Node *src,
                              const CL_Clip *clip,
                              const CH_Collection *coll,
                              const UT_String &export_path, 
                              OP_NodeList &affected,
                              UT_IntArray &indices,
                              orPath &pathparm);

    void                 getTrackDestinations(
                                const OP_Node *src,
                                UT_IntArray &track_indices,
                                OP_NodeList &nodes,
                                UT_PtrArray<PRM_Parm *> &parm_list,
                                UT_IntArray &vec_indices);

    void                 getDestinations( const OP_Node *src,
                                          UT_PtrArray<OP_Node *> &op_list );
    void                 getSources( const OP_Node *dest,
                                     UT_PtrArray<OP_Node *> &op_list,
                                     bool append );

    void                 unexportWithSameParmValues( float t, OP_Node *src );


    // these methods must be called with caution.
    // ie, only called by the static callback

    int                 getNumExports() const 
                        { return myData.entries(); }
    
    const orData        *getData(int idx) const
                        { return myData(idx); }
    
    orData              *getData(int idx)
                        { return myData(idx); }
    
private:

    UT_PtrArray<orData *>       myData;

    static float         theCallback(int data_idx, float time, int *tdepend,
                                     int *enable, const float *newVal);


    // Exactly one of clip/coll must be non-nil
    // If clip is given, exporting is done
    // If coll is given, copying is done

    int                 processDestNodes(OP_Node *src,
                                          const CL_Clip *clip,
                                          const CH_Collection *coll,
                                          OP_NodeList &dest_ops,
                                          OP_NodeList &affected,
                                         UT_IntArray &indices,
                                         OR_Mapping *mapping);

    int                 processParmList(OP_Node *src,
                                        OP_Node *dest_op,
                                        const char *channel_name,
                                        int track_idx,
                                        OP_NodeList &affected,
                                        UT_IntArray &indices,
                                        const CL_Clip *clip,
                                        const CH_Collection *coll);

    int                 processSingle(OP_Node *src,
                                        const CL_Clip *chop,
                                        int track_idx,
                                        OP_Node *dest_op,
                                        int parm_index,
                                        int vec_index,
                                        const CL_Track *enable_track,
                                        OP_NodeList &affected,
                                        UT_IntArray &indices
                                        );

    int                 processMapping(OP_Node *src,
                                       const CL_Clip *clip,
                                       OP_NodeList &affected,
                                       UT_IntArray &indices,
                                       OR_Mapping *mapping);


    int                 getNextDataIndex(OP_Node *dest,
                                         int parm_index, int vec_idx);

    int                 addData(OP_Node *dest, int parm_idx, int vec_idx,
                                OP_Node *source, int track_idx,
                                const CL_Track *enable_track);

    int                 myAddedUndoLevel;

};

OP_API extern OR_Manager  *ORgetManager();

#endif

---