---

KeyController.h

#ifndef KEYCONTROLLER_H
#define KEYCONTROLLER_H

#include "Controller.h"
#include "SpecificKeyIterator.h"

class VEditor_VKeyController;

#include "Editor_VKeyController.h"
#include <map>


template<class T> class VKeyController : public VController<T>
{
protected:
        map<int, T> m_mFrameKey;

public:
        VKeyController() {}
        VKeyController(VKeyController<T> *p) : VController<T>(p)
        {
                if (p != NULL)
                {
                        m_mFrameKey = p->m_mFrameKey;
                }
        }

        VController<T>* Clone()
        {
                return new VKeyController<T>(this);
        }

        string Identify() const {
                return string("Key Controller");
        }

protected:

        map<int, T>::iterator GetIterator( int pos )
        {
                map<int, T>::iterator mapiterator = m_mFrameKey.begin();
                for (; pos > 0 && mapiterator != m_mFrameKey.end(); pos-- )
                {
                        mapiterator++;
                }
                return mapiterator;
        }

public:



                void Delete(int pos)
                {
                        map<int, T>::iterator iter = GetIterator(pos);
                        if ( iter != m_mFrameKey.end() )
                                m_mFrameKey.erase( iter );
                }

                int Count() const
                {
                        return m_mFrameKey.size();
                }

                void SetFrame(int pos, int f)
                {
                        map<int, T>::iterator iter = GetIterator(pos);
                        if ( iter != m_mFrameKey.end() ) { // delete and re-insert
                        
                                T temp = iter->second;
                                m_mFrameKey.erase(iter);

                                m_mFrameKey.insert(pair<int, T>(f, temp));

                        }
                }

                int GetFrame(int pos)
                {
                        map<int, T>::iterator iter = GetIterator( pos );
                        if ( iter != m_mFrameKey.end() )
                                return iter->first;             
                        else
                                return -1;
                }

                bool Exists(int f) const
                {
                        return m_mFrameKey.find(f) != m_mFrameKey.end();
                }

                void CreateBlankKeyFrame( int frame )
                {
                        int pointer = 0; bool neg = false;
                        while ( Exists(frame + pointer))
                        {
                                pointer = abs(pointer) + 1;
                                if (neg)
                                        pointer *= -1;

                                neg = !neg;
                        }

                        AddUpdate( frame + pointer, Evaluate( frame + pointer ) );
                }

                VAbstractEditor* CreateKeyEditor( int pos )
                {
                        map<int, T>::iterator iter = GetIterator( pos );
                        if ( iter != m_mFrameKey.end() )
                                return iter->second.CreateEditor();
                        else
                                return NULL;
                }

                bool SupportsDirectManipulation() const
                {
                        return true;
                }




                void AddUpdate(int f, T key)
                {
                        m_mFrameKey[f] = key; // add or update
                }

                void SetKey(int pos, T key)
                {
                        map<int, T>::iterator iter = GetIterator(pos);
                        if ( iter != m_mFrameKey.end() )
                                iter->second = key; // set key
                }

                T GetKey(int pos) const
                {
                        map<int, T>::iterator iter = GetIterator(pos);
                        if ( iter != m_mFrameKey.end() )
                                return iter->second; // get frame
                        else 
                                return T();
                }





                T Evaluate(int nFrame)
                {
                        map<int, T>::iterator p, pStart, pEnd;
                        T ReturnValue;

                        p = m_mFrameKey.find(nFrame);
                        pStart = p;
                        pEnd = p;
                        
                        if ( p == m_mFrameKey.end() ) { // couldn't find
                                p = m_mFrameKey.begin();
                                while (p != m_mFrameKey.end()) {
                                        if (nFrame > p->first) {  // keep going
                                                p++;
                                        } else { // we're here
                                                pEnd   = p;
                                                pStart = --p;
                                                break;
                                        }
                                }                       
                                
                        } else { // found it!
                                ReturnValue = p->second;
                        }
                        
                        if (pStart == pEnd) { // no data
                                if ( m_mFrameKey.begin() != m_mFrameKey.end() ) // any data?
                                {
                                        if (nFrame >= ( m_mFrameKey.rbegin())->first) { // are we after the last frame?
                                                ReturnValue = ( --m_mFrameKey.end() )->second;
                                        } else {
                                                if ( p == m_mFrameKey.end() ) { // couldn't find
                                                        ReturnValue = m_mFrameKey.begin()->second;
                                                } else {
                                                        ReturnValue = p->second;
                                                }
                                        }
                                }
                        } else {    // linear tween
                                // slope * (x - x0) + y0
                                ReturnValue = ((pStart->second - pEnd->second) * (nFrame - pStart->first)) / (pStart->first - pEnd->first) + pStart->second;
                        }

                        return ReturnValue;
                                        
                }

                VAbstractEditor* CreateEditor() 
                {
                        return new VEditor_VKeyController(this);
                }

                void OnLink()
                { // create a first blank keyframe
                        AddUpdate( m_nStartFrame, Evaluate(m_nStartFrame) );
                }

};


#endif

---