CH/CH_Channel.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 Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Channel Library (C++)
 *
 * COMMENTS:    Definition of a channel
 *
 */

#ifndef __CH_Channel_h__
#define __CH_Channel_h__

#include "CH_API.h"
#include <iostream.h>
#include <UT/UT_Algorithm.h>
#include <UT/UT_Defines.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_String.h>
#include <UT/UT_SuperInterval.h>
#include <UT/UT_IStream.h>
#include "CH_Collection.h"

class UT_Vector2;
class UT_FloatArray;

typedef enum {
    CH_VALUE = 0,
    CH_SLOPE,
    CH_ACCEL,
    CH_NUM_VALUES
} CH_ValueTypes;

CH_API extern char
CHvalueNames[2][CH_NUM_VALUES];

typedef enum {
    CH_CHANNEL_DEFAULT,  // Channel is default value beyond defined range
    CH_CHANNEL_HOLD,     // Channel is start/end value before/after
    CH_CHANNEL_CYCLE,    // Channel wraps to defined range
    CH_CHANNEL_EXTEND,   // Channel function continues outside start/end
    CH_CHANNEL_SLOPE     // Channel extends at start/end slope
} CH_ChannelBehavior;
UT_SWAPPER_SIMPLE(CH_ChannelBehavior);

//
//  This enum is used when calling the changeSegLength method and provides
//  a hint as to how the change is to be done. This is currently only
//  necessary when changing the length of raw segments and the channel
//  manager raw interpolation option is turned off.
//
typedef enum {
    CH_SCALE_ANY,               // Don't care.
    CH_SCALE_START,             // Adjusting the segment start time.
    CH_SCALE_END                // Adjusting the segment end time.
} CH_SegmentScale;

// NB: This enum only has 8 bits.
// Do not change these values as they get saved.
typedef enum {
    CH_CHANNEL_NONE         = 0x00,
    CH_CHANNEL_MODIFIED     = 0x01,
    CH_CHANNEL_COOKING      = 0x02,
    CH_CACHE_ENABLED        = 0x04,
    CH_CHANNEL_SPARE        = 0x08,     // no longer used!
    CH_CHANNEL_ACTIVE       = 0x10,

    CH_CHANNEL_PENDING      = 0x20,
    CH_CHANNEL_PENDINGHOLD  = 0x40,

    CH_CHANNEL_LOCKED       = 0x80,

    // flags to save
    CH_CHANNEL_SAVE_MASK    = CH_CHANNEL_PENDING,

    CH_CHANNEL_FLAG_MASK    = 0xFF      // sentinel: we've only got 8 bits
} CH_ChannelFlag;


class CH_Segment;
class CH_Manager;
class CH_SegmentRef;


class CH_API CH_HalfKey
{
public:
    float       myV[ CH_NUM_VALUES ];
    bool        myVValid[ CH_NUM_VALUES ];
    bool        myVTied[ CH_NUM_VALUES ];
};
UT_SWAPPER_SIMPLE(CH_HalfKey);

class CH_API CH_Key
{
public:
    float       myTimeValue;
    bool        myEvaluatedSlopes;
    CH_HalfKey  k[2];

    CH_Key() { clear(); }

    void        display() const;

    void        clear();

    // direction is one of -1, 0, 1
    // -1 = tie using left value
    // 0 = tie averaging both
    // 1 = tie using right value
    void        tie( int direction, CH_ValueTypes t );

    void        tie( int direction );

    void        set( CH_ValueTypes t, float value );
    bool        isSet( CH_ValueTypes t );

    void        complete();

    void        get( CH_Segment *left_seg, CH_Segment *right_seg,
                     bool accel_ratio = true );

    void        put( CH_Segment *left_seg, CH_Segment *right_seg,
                     bool accel_ratio = true ) const;

    void        stretch( float xscale, float yscale, bool accel_ratio );

    void        changeAccelsToRatios( float left_seg_len, float right_seg_len );

    void        reverse();

    void        opscript( ostream &os, bool use_time,
                            bool only_valid=true ) const;
};

class CH_API CH_FullKey: public CH_Key
{
public:
    bool        myUseExpression;
    UT_String   myExpression;
    CH_ExprLanguage myExprLanguage;

    CH_FullKey()
    {
        myUseExpression = false;
        myExprLanguage = CH_OLD_EXPR_LANGUAGE;
    }

    CH_FullKey( CH_FullKey const& other );
    CH_FullKey &operator=( CH_FullKey const& other );

    void        display() const;
};

class CH_API CH_ReversibleKey: public CH_FullKey
{
public:
    bool        myUseRevExpression;
    UT_String   myRevExpression;
    CH_ExprLanguage myRevExprLanguage;

    CH_ReversibleKey()
    {
        myUseRevExpression = false;
        myRevExprLanguage = CH_OLD_EXPR_LANGUAGE;
    }

    CH_ReversibleKey( CH_ReversibleKey const& other );
    CH_ReversibleKey &operator=( CH_ReversibleKey const& other );

    void        display() const;

    void        stretch( float xscale, float yscale, bool accel_ratio );

    void        reverse();
};

//
// Iterator for going through .chn and .bchn files, 
// channel by channel, until the end of channels for current collection is
// reached. The iterator can be restarted by calling begin() again.
//
class CH_API CH_ChannelIterator
{
// After using begin or nextChannel, the position in the stream
// will be proper for using CH_Channel::load or CH_Collection::loadChannelRange
public:
    CH_ChannelIterator(UT_IStream &is, int binary);
    bool begin(UT_String &name, const UT_String *path=NULL);
    bool end() { return noMoreChannels; }
    bool nextChannel(UT_String &name);
    int getLastError() { return lastError; }

private:
    UT_IStream *curr_is;
    UT_String curr_coll;
    int is_binary;
    int lastError;
    bool noMoreChannels;
};

class CH_API CH_Channel
{
public:
    typedef enum
    {
        SNAP_SNAP,
        SNAP_SNAP_AND_DELETE,
        SNAP_REPLACE,
        SNAP_REPLACE_DOUBLE
    } SnapType;

    CH_Channel(CH_Collection *dad, const char *name, float default_value = 0,
               const char *default_string = 0);
    CH_Channel(CH_Collection *dad, const CH_Channel &from);
   ~CH_Channel();

    void                 initializeFirstSegment(const char *expr,
                                                CH_ExprLanguage language);
    
    // Initialize parents of mySegments and myDisableSegments to this
    void                 initializeSegmentParents();
    
    // UTILITIES
    void                 clear();
    void                 swap( CH_Channel &other );

    const UT_String     &getName(void) const { return myName; }
    const UT_String     &getAlias(void) const;
    void                 getFullPath( UT_String &path ) const;

    //  Used only by CH_Collection
    void                 setName(const char *s)  { myName.harden(s); }
    void                 setAlias(const char *s) { myAlias.harden(s); }

    CH_Manager          *getManager()   const { return myParent->getManager(); }

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

    // This returns if the channel is time dependent without evaluating
    // the channel.
    bool                 isTimeDependent() const;

    // These return if the channel is time dependent and will catch more cases
    // than isTimeDependent() by evaluating the channel.
    bool                 isTimeDependentSlow(int thread) const;
    bool                 isStringTimeDependentSlow(int thread) const;

    bool                 hasNonIntegerKeys() const;
    bool                 isDataDependent(float gtime) const;

    // are we using a zero-length segment to represent one key?
    bool                 hasOnlyOneSegment() const;

    bool                 isRotationChannel() const;

    // KEYS
    bool                 getSurroundingSegs( float gtime,
                            CH_Segment *&left, CH_Segment *&right ) const;

    CH_Segment          *getSegmentAfterKey( float gtime ) const;

    //  isAtKey returns true if the channel is considered modifiable at
    //  the given time. This means there's either no segment there or the
    //  segment is constant or there's a timemark there (segment start|end).
    bool                 isAtKey(float gtime) const;

    //  isAtHardKey returns true only if there's a timemark (segment start
    //  or end) at the given time.
    bool                 isAtHardKey(float gtime) const;
    bool                 isAtHardKeyframe(int frame) const;

    float                findKey(float gtime, float direction) const;
    int                  findKeyframe(int frame, int direction) const;

    // returns true when no more times in the range
    bool                 nextTimeInRange( UT_SuperInterval const& range,
                                            float &t, bool first ) const;

    // sample functions evaluate the channel to find values
    // getKey functions only evaluate if the time is not already at a hard key
    void                 sampleValueSlope( CH_Segment *seg, float gtime,        
                                           int thread, float &v, float &s );
    bool                 sampleVSA( CH_Segment *seg, float gtime, int thread,
                                            float &v, float &s, float a[2] );
    void                 sampleKey( CH_Segment *seg, float gtime, int thread,
                                    CH_Key &key );
    bool                 getKey( float gtime, CH_Key &key,
                                 bool accel_ratios = true );
    bool                 getFullKey( float gtime, CH_FullKey &key,
                                     bool reverse = false,
                                     bool accel_ratios = true );
    bool                 getReversibleKey( float gtime, CH_ReversibleKey &key );

    void                 putKey( float gtime, CH_Key const& key,
                                 bool accel_ratios = true );
    void                 putFullKey( float gtime, CH_FullKey const& key,
                                     bool accel_ratios = true );

    void                 transferKey(float to_time,
                            CH_Channel *from_chp, float from_time);

    void                 applyPendingToKey( CH_Key &key, float gtime );
    void                 applyAutoSlopeToKey( CH_Key &key );

    // The segment returned will have
    // it's start time at the global time given except for the case where the
    // global time was beyond the channel length and a segment was appended
    void                 insertKeyFrame(float global_t);
    void                 destroyKeyFrame(float global_t);
    void                 moveKeyFrame( float old_gtime, float new_gtime );

    void                 saveKeyFrameForUndo( float global_t );

    // this function is a bit confusing
    // Sets the in/out values for a segment to the val at a time specified
    //The method returns 0 if it was successfull,
    //                     -1 if there was no key at the time specified
    // set_pending = if true,the pending value is set to val, unless commit_keys
    //               is true, and gtime falls on a key frame.
    // commit_keys = if true and gtime falls on a key frame, the keyed value
    //               for that frame is set to val, pending is cleared if 
    //               set_pending is true
    int                  setKeyValue(float val, float gtime,
                                     bool set_pending = false,
                                     bool commit_keys = true,
                                     bool propagate = true);
    int                  setKeyString(const UT_String &str, float gtime,
                                      bool set_pending = false,
                                      bool commit_keys = true,
                                      bool propagate = true);
    int                  setKeyString(const UT_String &str, float gtime,
                                      CH_ExprLanguage language,
                                      bool set_pending = false,
                                      bool commit_keys = true,
                                      bool propagate = true);
    void                 holdValue( float gtime, int thread );

    // utility functions for getting keyframe numbers:
    // they return array of keyframes in the channel 
    // the frames are unique and sorted in a ascending order.
    void                 getKeyFrames( UT_SuperInterval const& range,
                                        UT_IntArray &frames,
                                        bool error_frames_only );

    /// Similar to the above, but gets times of all keys in the channel
    /// in the specified range.
    void                 getKeyTimes( UT_SuperInterval const& range,
                                        UT_FloatArray &times,
                                        bool error_frames_only );

    // the frames are unique and sorted in a descending order.
    void                 getDisabledFrames(UT_IntArray &frames,
                                             int minframe, int maxframe);

    // EXPRESSIONS
    CH_Segment          *getExpressionSegment( float gtime ) const;
    const char          *getExpression( float gtime ) const;
    bool                 changeExpression( float gtime,
                                            const char *expr,
                                            CH_ExprLanguage language,
                                            bool convert_accels );
    CH_ExprLanguage      getCollectionExprLanguage() const;
    CH_ExprLanguage      getExprLanguageAtTime(float time) const;
    void                 setExprLanguage(CH_ExprLanguage language);
    void                 setExprLanguageAtTime(CH_ExprLanguage language,
                                               float time);

    // If we were to ask for the value of the channel as a string at a
    // particular time, this function returns what the meaning of that string
    // would be (either a literal or expression in some language).
    CH_StringMeaning     getStringMeaning(float time) const;

    // MULTI-SEGMENT MANIPULATION
    void         clearSegments();

    void         deleteKeys( UT_SuperInterval const& range );

    bool         copyRangeOverwritesKeys(const CH_Channel &src,
                                    UT_SuperInterval const& range,
                                    UT_Interval const& to_range);
    bool         copyRangeOverwritesFrames(const CH_Channel &src,
                                    UT_SuperInterval const& range,
                                    UT_Interval const& to_range);
    bool         copyRangeOverwrites(const CH_Channel &src,
                                    UT_SuperInterval const& range,
                                    UT_Interval const& to_range);

    void         copyRange(const CH_Channel &src,
                                    UT_SuperInterval const& range,
                                    UT_Interval const& to_range);

    // copyContents copies everything except name and parent
    void         copyContents(const CH_Channel &from);
    void         swapContents( CH_Channel &other );
    // TODO remove this function:
    // copy a range of keys. Assumes that we already have keys in the src
    // channel at those times
    // another way to do this is: (once we pass UT_SuperInterval by value)
    // ch.clear();
    // ch.copyRange( src, UT_SuperInterval( start, end ), 0.0f );
    void         copyRange(const CH_Channel &src,
                                   float global_start, float global_end);

    // if os is provided, a verbose description of what's happening is printed
    void         snapKeysInRange( const UT_SuperInterval &range,
                                    SnapType type=SNAP_SNAP, ostream *os=0 );

    // ENTIRE CHANNEL MANIPULATION
    void        scroll (float newStart, bool update = true);
    void        stretch(float newStart, float newEnd);
    void        reverse(float gstart=0, float gend=0, bool whole_chan = true);
    // scroll on the y axis (returns success)
    bool        increaseKeyValues( float delta );

    // DISABLING
    bool        isAllDisabled() const;
    bool        isAllEnabled() const;
    bool        isDisabled(float gtime) const;
    void        disableAll(float gtime);
    void        enableAll();
    void        disable(float gstart, float gend);
    void        enable(float gstart, float gend);

    // PENDING METHODS
    int                  isPending() const
                            { return (myFlags & CH_CHANNEL_PENDING) ? 1 : 0; }
    int                  isPending(float gtime) const;
    int                  isPendingLocal(float ltime) const;
    void                 clearPending();
    void                 updatePending( float gtime );
    float                getPendingEvalTime() const
                            { return globalTime(myPendingEvalTime); }
    int                  isPendingHold() const
                         { return (myFlags & CH_CHANNEL_PENDINGHOLD) ? 1 : 0; }
    void                 setPendingHold( int state );

    // SAVE and LOAD
    void                 save(ostream &os, int binary, bool compiled) const;
    bool                 load(UT_IStream &is);
    void                 display() const;
    void                 displayAsKeys() const;

    void                 setDefaultValue(float dv) { myDefValue = dv; }
    float                getDefaultValue() const   { return myDefValue; }

    void                 setDefaultString(const UT_String &dv)
                         { myDefString.harden(dv); }
    UT_String            getDefaultString() const   { return myDefString; }

    void                 setChannelLeftType(CH_ChannelBehavior t);
    void                 setChannelRightType(CH_ChannelBehavior t);
    CH_ChannelBehavior   getChannelLeftType(void) const  { return myLeftType; }
    CH_ChannelBehavior   getChannelRightType(void) const { return myRightType; }

    static const char   *getChannelTypeName(CH_ChannelBehavior type);

    void                 setCollection(CH_Collection *chp){ myParent = chp; }
    const CH_Collection *getCollection() const { return myParent; }
    CH_Collection       *getCollection()       { return myParent; }

    void                 setIsTemporary( bool temp ) { myIsTemporary = temp; }
    bool                 isTemporary() const { return myIsTemporary; }

    // FLAGS
    void                 setChangeActive(int state)
                         {
                            if( state ) myFlags |=  CH_CHANNEL_ACTIVE;
                            else        myFlags &= ~CH_CHANNEL_ACTIVE;
                         }
    bool                 isChangeActive() const
                         { return (myFlags & CH_CHANNEL_ACTIVE) ? 1 : 0; }
    

    bool                 getLocked() const
                         { return ((myFlags & CH_CHANNEL_LOCKED) != 0); }
    void                 setLocked(bool f);

    int                  getChanged() const
                         { return (myFlags & CH_CHANNEL_MODIFIED) ? 1 : 0; }
    void                 setChanged(bool on,
                                    CH_CHANGE_TYPE type = CH_CHANNEL_CHANGED);
    void                 dirtyExprCache();

    // Used only by CH_Segment and CH_Channel
    int                  isCacheEnabled() const
                         { return (myFlags & CH_CACHE_ENABLED) ? 1 : 0; }
    void                 setCacheEnable(bool on_off)
                         {
                            if (on_off) myFlags |=  CH_CACHE_ENABLED;
                            else        myFlags &= ~CH_CACHE_ENABLED;
                         }
    int                  canAccess(uint mask) const
                         {
                             return myParent->canAccessChannel(mask, this);
                         }

    // map collection time to channel time...
    float       localTime(float t)   const { return (t-myStart); }

    // map channel time to global time...
    float       globalTime(float t)  const { return t + myStart; }

    // Returns collection global time...
    float       getStart()           const { return myStart; }
    float       getEnd()             const { return myStart + myLength;}
    float       getLength()          const { return myLength; }

    // Used to reset the local variables:
    void                 unresolveLocalVars(int thread);

    // Op dependencies
    void                 buildOpDependencies(void *ref_id, int thread);
    void                 changeOpRef(const char *new_fullpath,
                                     const char *old_fullpath,
                                     const char *old_cwd,
                                     const char *chan_name,
                                     const char *old_chan_name,
                                     int thread);

    // Enable or disable value caching in expression segments...
    void         cook(int state);

    // Load values as keys. Returns the number of samples actually loaded.
    int          setRawValues(float from, float to, float *vals, int nsamples);

    // Returns global time...
    void         setScope(bool on_off);
    bool         isScoped() const { return myScope; }

    // Does this channel have any segments with editable components (eg. value,
    // slope, acceleration, etc.)?
    bool         isEditable();

    // Query methods. Used only by CH_Collection
    float        evaluate(float t, bool no_disabling, int thread);
    void         evaluate(float from, float to, float *vals, int nsamples,
                          bool no_disabling, bool use_cache, int thread);
    float        evaluateSegment(CH_Segment *eval, float localtime,
                                 bool extend, int thread);
    void         evaluateString(UT_String &result, float t, int thread);
    void         evaluateStringSegment(UT_String &result, CH_Segment *eval,
                                       float localtime, bool extend,
                                       int thread);

    int          findString(const char *str, bool fullword,
                            bool usewildcards) const;
    int          changeString(const char *from, const char *to,
                              bool fullword, bool update /*= true*/,
                              int thread);

//  Used only by CH_Collection
    const CH_Segment    *getEvaluationSegment(int thread) const
                        {
                            return myEvalData.getValueForThread(thread)
                                                            .myEvalSegment;
                        }
    CH_Segment          *getEvaluationSegment(int thread)
                        {
                            return myEvalData.getValueForThread(thread)
                                                            .myEvalSegment;
                        }
    const CH_Segment    *getPrevEvaluationSegment(int thread) const;
    CH_Segment          *getPrevEvaluationSegment(int thread);
    const CH_Segment    *getNextEvaluationSegment(int thread) const;
    CH_Segment          *getNextEvaluationSegment(int thread);
    float        getLocalTime(int thread) const
                        {
                            return myEvalData.getValueForThread(thread)
                                                            .myEvalTime;
                        }
    float        getInTime(int thread) const;
    float        getOutTime(int thread) const;
    float        getPrevInTime(int thread) const;
    float        getNextOutTime(int thread) const;

    // Used only by CH_Segment and CH_Channel
    void         setEvalTime(float localtime, int thread);


    // This method will attempt to match the channel name with the pattern,
    // searching as many parents as necessary regardless of the cwd
    // eg. tx will match true with tx xform1/tx geo1/xform1/tx

    int         match(const char *pattern) const;


    // sets all keys to be 'value', and zeros all slopes & accels.
    void         setConstantValue(float value);
   
    // sets the data and keys so that the channel approximates the
    // raw data of samples within given error using cubic interpolation
    // INPUTS:
    //   data      - an array of pairs (time, value) to be fitted. 
    //   n_pts     - number of elements in data array
    //   error2    - the error to which the channel should approximate data
    //   delete_old_segments - if true, all old segments are cleared before
    //               new ones are generated from data. If false, the segments
    //               that fit the data replace old segments (thus, some
    //               old segments that are outside of the data range will 
    //               remain unchanged)
    // OUTPUTS:
    //             The clip will approximate the curve sampled by data.
    //             The clip will have its start time equal to
    //             the time component of the first pair in the data array,
    //             and the end time equal to the time of the last pair.
    // RETURNS:    
    //             True on success, false if failed. 
    bool         fitToPointData( UT_Vector2 *data, int n_pts, 
                                 bool preserveExtrema,
                                 float error2 = 0.01f,
                                 bool delete_old_segments = false);

    // refits the channel data (or portion of it) with cubic interpolation 
    // within given error tolerance. Inserts new keys, etc.
    // delete_old_segments - if true, all segments are deleted before
    //     refitted range is inserted. Otherwise, old segments outside of the
    //     refitted range are not affected.
    void         refit( float tolerance, bool preserveExtrema );
    void         refit( float tolerance, bool preserveExtrema,
                        float from_gtime, float to_gtime,
                        bool delete_old_segments);

    // SEGMENT MANAGEMENT
    bool         isEmpty() const;
    int          getNSegments() const;
    int          getNKeys() const;
    int          getNKeysBefore( float gtime ) const;
    int          getNKeysBeforeOrAt( float gtime ) const;

    float        getKeyTime( unsigned idx ) const;

    unsigned     getSegmentIdx(float local_time) const;
    CH_Segment  *getSegment(unsigned idx) const;
    CH_Segment  *getSegment(float local_time) const;

    CH_Segment  *getNextSegment(unsigned idx) const; // Depends on behavior
    CH_Segment  *getPrevSegment(unsigned idx) const; // Depends on behavior

    CH_Segment  *getPrevSegment(CH_Segment *) const; // This one does not wrap!
    CH_Segment  *getNextSegment(CH_Segment *) const; // This one does not wrap!

    CH_Segment  *getFirstSegment()  const
                 { 
                     // empty means no keys in the channel if user delete them
                     // all
                     UT_ASSERT_P( isEmpty() || myEndSegment );
                     return isEmpty()
                        ? 0 : getSegment( (unsigned)0 );
                 }
    CH_Segment  *getLastSegment()  const
                 { 
                     // empty means no keys in the channel if user delete them
                     // all
                     UT_ASSERT_P( isEmpty() || myEndSegment );

                     // old behaviour maintained (ie. don't use end segment)
                     return isEmpty()
                        ? 0 : getSegment( (unsigned)mySegments.entries()-1 );
                 }

    int64        getMemUsage(bool onlythis) const;

    //  The first method takes global time, the second, segment local time.
    void         changeSegLength     (CH_Segment *seg, float gtime,
                                        CH_SegmentScale how = CH_SCALE_ANY,
                                        bool update = true);

private:
                 CH_Channel( CH_Channel const& other ); // unimplemented

    void         ensureEndSegmentCreated();
    void         updateEndSegment();
    void         destroyEndSegment();

    void         moveKeyInternal( float old_gtime, float new_gtime );
    void         splitSegment(float gtime, bool accel_ratio = true);

    // cuts out a portion of a channel. Returns an index at which the cut began
    int          cutOut( float from_gtime, float to_gtime );

    void         changeSegLocalLength(CH_Segment *seg, float ltime,
                                        CH_SegmentScale how = CH_SCALE_ANY,
                                        bool update = true);

    CH_Segment  *appendSegment(CH_Segment *seg);
    CH_Segment  *insertSegment(CH_Segment *seg, unsigned idx);

    // remove but don't delete
    void         removeSegment(CH_Segment *seg);
    void         removeSegment(unsigned idx);   // Remove the idx segment

    void         deleteSegment(CH_Segment *);
    void         deleteSegment(unsigned idx);   // Delete the idx segment

    int          getNDisableSegments(void) const
                 { return myDisableSegments.entries(); }
    CH_Segment  *getDisableSegment(unsigned idx) const
                 {
                    return (idx < myDisableSegments.entries()) ?
                            myDisableSegments(idx) : 0;
                 }

    CH_Segment  *getDisableSegment(float local_time) const;
    CH_Segment  *getPrevDisableSegment(CH_Segment *) const;
    CH_Segment  *getNextDisableSegment(CH_Segment *) const;

    int          getDisableSegmentIndex(float ltime, bool closest_prev) const;

    CH_Segment  *getFirstDisableSegment()  const
                 { 
                    return (myDisableSegments.entries() > 0) ?
                        myDisableSegments(0) : 0;
                 }
    CH_Segment  *getLastDisableSegment()  const
                 { 
                    return (myDisableSegments.entries() > 0)
                          ? myDisableSegments(myDisableSegments.entries()-1)
                          : 0;
                 }
    CH_Segment  *appendDisableSegment(CH_Segment *seg);

    CH_Segment  *insertDisableSegment(CH_Segment *seg);
    CH_Segment  *insertDisableSegment(CH_Segment *seg, int idx);
    CH_Segment  *insertDisableSegment(CH_Segment *seg, CH_Segment *before);

    // Remove but don't delete
    void         removeDisableSegment(CH_Segment *seg);
    void         removeDisableSegment(int idx);

    void         deleteDisableSegment(CH_Segment *);
    void         deleteDisableSegment(int idx);

    void         setPending( bool on_off, float ltime );
    void         updatePendingStateToManager();

    void         deNormalize(float scale);

    int          isCooking() const
                 {
                    return (myFlags & CH_CHANNEL_COOKING) != 0;
                 }
    void         setCooking(bool on_off)
                 {
                    if (on_off) myFlags |=  CH_CHANNEL_COOKING;
                    else        myFlags &= ~CH_CHANNEL_COOKING;
                 }

    void         adjustSegmentTimes(bool update = true);
    void         cook(CH_Segment *, int state);

    CH_Collection               *myParent;      // Who I belong to
    UT_String                    myName;
    UT_String                    myAlias;

    CH_ChannelBehavior           myLeftType;    // Type of channel
    CH_ChannelBehavior           myRightType;   // Type of channel
    CH_Segment                  *myEndSegment;

    float                        myDefValue;    // Default/Pending value
    float                        myStart;       // Start time of channel
    float                        myLength;      // Kept for efficiency (local)

    UT_String                    myDefString;   // Default/Pending string value

    UT_PtrArray<CH_Segment *>    mySegments;    // Array of segments
    UT_PtrArray<CH_Segment *>    myDisableSegments;

    bool                         myScope;
    bool                         myIsTemporary;
    unsigned char                myFlags;

                                                
    float                        myPendingEvalTime;

    class EvalData
    {
    public:
        EvalData() : myEvalTime(0.0f), myEvalSegment(0)
            { }

        void set(float ltime, CH_Segment *seg)
        {
            myEvalTime = ltime;
            myEvalSegment = seg;
        }

        void set(float ltime, CH_Segment *seg,
                 float &old_ltime, CH_Segment *&old_seg)
        {
            old_ltime = myEvalTime;
            old_seg = myEvalSegment;
            set(ltime, seg);
        }

        float        myEvalTime;        // Local time of evaluation
        CH_Segment  *myEvalSegment;     // Segment I'm evaluating at
    };

    UT_ThreadSpecificValue<EvalData> myEvalData;
};

inline void
UTswap(CH_Channel &x, CH_Channel &y)
{
    x.swap(y);
}

/// This function stretches the modifies the given slope and accel values
/// according to the given factors. If the accel value is given as a ratio,
/// then accel_ratio should be true.
CH_API extern void
CHstretchSlopeAccel(float xscale, float yscale, float &slope, float &accel,
                    bool accel_ratio);

// this will move attempted_dt towards accepted_dt so that:
// keys[i]+attempted_dt does not land on another key
// attempted_dt stays on the same side of accepted_dt as it started
//      (so that if you're moving one way, they don't snap backwards before
//      where they started)
// if snap_to_frame, attempted_dt+base_time will land on a frame
CH_API extern void
CHfindMoveKeysDelta( const CH_Channel *chp, bool snap_to_frame, float base_time,
                        const UT_FloatArray &orig_keys,
                        float accepted_dt, float &attempted_dt );

CH_API extern void
CHmoveKeysWithDelta( CH_Channel *chp, const UT_FloatArray &orig_keys,
                        float old_accepted_dt, float new_accepted_dt );

#endif

---