---

SpecificProperty.h

#ifndef SPECIFICPROPERTY_H
#define SPECIFICPROPERTY_H

#include "GenericProperty.h"
#include "Controller.h"
#include "KeyController.h"
#include "ControllerFactory.h"

#include "AbstractEditable.h"
#include "AbstractEditor.h"

class CShapePropertiesDialog;

template<class T> class VSpecificProperty : public VGenericProperty, public VSpecificKeyIterator<T>
{
friend class CShapePropertiesDialog;
protected:

        VController<T>* m_pControl;

        T m_BaseValue;

        int m_BaseFrame;

public:
        VSpecificProperty()
        {
                m_pControl  = NULL;
                m_BaseFrame = 0;
        }

        VSpecificProperty(VSpecificProperty<T>* p)
        {
                if (p != NULL)
                {
                        if ( p->GetController() )
                        {
                                m_pControl  = p->GetController()->Clone();
                        }
                        else
                        {
                                m_pControl = NULL;
                        }

                        m_BaseValue = p->m_BaseValue;
                        m_BaseFrame = p->m_BaseFrame;

                }
        }

        virtual VSpecificProperty<T>* Clone()
        {
                return new VSpecificProperty<T>(this);
        }




                virtual string Identify() const  { return string(""); }

                string IdentifyController() const 
                {
                        if (m_pControl != NULL)
                                return m_pControl->Identify();
                        else
                                return string("");
                }

                bool IsControlled() const 
                {
                        if (m_pControl)
                                return true;
                        else
                                return false;
                }

                virtual bool MaintainsLinkToShape(void* p) const
                {
                        if (m_pControl != NULL)
                                return m_pControl->MaintainsLinkToShape(p);
                        else
                                return false;
                }

                virtual void UnlinkShape(void* p)
                {
                        if (m_pControl != NULL)
                                m_pControl->UnlinkShape(p);
                }



        void SetBase( T BaseValue )
        {
                m_BaseValue = BaseValue;
        }

        T GetBase() const 
        {
                return m_BaseValue;
        }

        void SetController(VController<T>* pNewCtrl)
        {
                int nStartFrame = 0;
                int nEndFrame = 50;
                if (m_pControl != NULL) {
                        nStartFrame = m_pControl->StartFrame();
                        nEndFrame = m_pControl->EndFrame();
                        delete m_pControl;
                }

                m_pControl = pNewCtrl;

                if (m_pControl != NULL) { // our new controller exists?
                        m_pControl->StartFrame(nStartFrame);
                        m_pControl->EndFrame(nEndFrame);
                        m_pControl->OnLink();
                }
        }

        VController<T>* GetController()
        {
                return m_pControl;
        }




                virtual void Delete(int pos)
                {
                        if (m_pControl != NULL)
                                if (m_pControl->SupportsDirectManipulation())
                                        m_pControl->Delete(pos);
                }

                virtual int Count() const 
                {
                        if (m_pControl != NULL) {
                                if (m_pControl->SupportsDirectManipulation())
                                        return m_pControl->Count();
                                else
                                        return -1;
                        } else
                                return 0;
                }

                virtual void SetFrame(int pos, int f)
                {
                        if (m_pControl != NULL) {
                                if (m_pControl->SupportsDirectManipulation())
                                        m_pControl->SetFrame(pos, f);
                        } else
                                m_BaseFrame = f;
                }

                virtual int GetFrame(int pos) 
                {
                        if (m_pControl != NULL) {
                                if (m_pControl->SupportsDirectManipulation())
                                        return m_pControl->GetFrame(pos);
                                else
                                        return -1;
                        } else
                                return -1;
                }

                bool Exists(int f) const 
                {
                        if (m_pControl)
                                return m_pControl->Exists( f );
                        else
                                return false;
                }

                virtual void CreateBlankKeyFrame( int frame )
                {
                        if (m_pControl != NULL) {
                                if (m_pControl->SupportsDirectManipulation() && !m_pControl->Exists(frame)) {
                                        m_pControl->AddUpdate(frame, m_pControl->Evaluate(frame));
                                }
                        }
                }



                virtual void AddUpdate(int f, T key)
                {
                        if (m_pControl != NULL) {
                                if (m_pControl->SupportsDirectManipulation())
                                        m_pControl->AddUpdate(f, key);
                        } else { // convert this to a keycontroller
                                m_pControl = new VKeyController<T>;
                                if (m_pControl)
                                {
                                        m_pControl->AddUpdate(m_BaseFrame, m_BaseValue);
                                        m_pControl->AddUpdate(f, key);
                                }
                                else
                                {
                                        OutOfMemoryIndicator( AfxGetMainWnd()->m_hWnd );
                                }

                        }
                }

                virtual void SetKey(int pos, T key)
                {
                        if (m_pControl != NULL) {
                                if (m_pControl->SupportsDirectManipulation())
                                        m_pControl->SetKey(pos, key);
                        } else
                                m_BaseValue = key;
                }

                virtual T GetKey(int pos)
                {
                        if (m_pControl != NULL) {
                                if (m_pControl->SupportsDirectManipulation())
                                        return m_pControl->GetKey(pos);
                                else
                                        return m_BaseValue;
                        } else
                                return m_BaseValue;
                }




                virtual T Evaluate(int nFrame) // Basic property evaluated without adding basevalue
                {
                        if (m_pControl != NULL)
                                return m_pControl->Evaluate(nFrame);
                        else
                                return m_BaseValue;
                }

                virtual VAbstractEditor* CreateEditor()
                {
                        if (IsControlled())
                                return m_pControl->CreateEditor();
                        else
                                return m_BaseValue.CreateEditor();
                }


                virtual bool SupportsDirectManipulation() const 
                {
                        if (m_pControl != NULL)
                                return m_pControl->SupportsDirectManipulation();
                        else
                                return true;
                }










                virtual int ControllerCount() const { return 1;}

                virtual void ImplementController( int index )
                {
                        VKeyController<T>* p = new VKeyController<T>();
                        if (p)
                                SetController(p);
                }

                virtual string ControllerInfo( int index ) const
                {
                        return string("");
                }

                void UnlinkController( )
                {
                        SetController(NULL);
                }

};

#endif

---