notetrck.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 1998-2006 Autodesk, Inc.
// All rights reserved.
// 
// These coded instructions, statements, and computer programs contain
// unpublished proprietary information written by Autodesk, Inc., and are
// protected by Federal copyright law. They may not be disclosed to third
// parties or copied or duplicated in any form, in whole or in part, without
// the prior written consent of Autodesk, Inc.
//**************************************************************************/
// FILE:        notetrck.h
// DESCRIPTION: Note track plug-in class
// AUTHOR:      Rolf Berteig
// HISTORY:     created July 20, 1995
//**************************************************************************/
#pragma once
#include "maxheap.h"
#include "ref.h"
#include "plugapi.h"
#include "AnimPropertyID.h"
#include "TrackClipObject.h"

class NoteTrack : public ReferenceTarget {
    public:
        SClass_ID SuperClassID() {return SClass_ID(NOTETRACK_CLASS_ID);}
        RefResult AutoDelete() {return REF_SUCCEED;}
    };

class NoteAnimProperty : public AnimProperty {
    public:     
        NoteTrack *note;
        DWORD ID() {return PROPID_NOTETRACK;}

        NoteAnimProperty(NoteTrack *n=NULL) {note = n;}
        ~NoteAnimProperty() {if (note) note->DeleteMe();}
    };


CoreExport NoteTrack *NewDefaultNoteTrack();




// Standard note track plug-in class definitions:

// Note Key Flags
#define NOTEKEY_SELECTED    (1<<0)
#define NOTEKEY_LOCKED      (1<<1)
#define NOTEKEY_FLAGGED     (1<<2)

class NoteKey: public MaxHeapOperators {
    public:
        TimeValue time;
        MSTR note;
        DWORD flags;
        
        NoteKey(TimeValue t,const MSTR &n,DWORD f=0) {time=t;note=n;flags=f;}
        NoteKey(NoteKey& n) {time=n.time;note=n.note;flags=n.flags;}

        void SetFlag(DWORD mask) { flags|=(mask); }
        void ClearFlag(DWORD mask) { flags &= ~(mask); }
        BOOL TestFlag(DWORD mask) { return(flags&(mask)?1:0); }
    };

class NoteKeyTab : public Tab<NoteKey*> {
    public:
        ~NoteKeyTab() {Clear();}
        CoreExport void Clear();
        CoreExport void DelKey(int i);
        CoreExport NoteKeyTab &operator=(NoteKeyTab &keys);
        CoreExport void KeysChanged();
    };

class NoteKeyClipObject : public TrackClipObject {
    public:
        NoteKeyTab tab;

        Class_ID ClassID() {return Class_ID(NOTETRACK_CLASS_ID,0);}
        SClass_ID SuperClassID() { return NOTETRACK_CLASS_ID; }
        CoreExport void DeleteThis();

        NoteKeyClipObject(Interval iv) : TrackClipObject(iv) {}
    };

class DefNoteTrack : public NoteTrack {
    public:
        NoteKeyTab keys;
        
        DefNoteTrack() {}
        DefNoteTrack(DefNoteTrack &n) {keys=n.keys;}
        DefNoteTrack& operator=(DefNoteTrack &track) {keys=track.keys;return *this;}
        CoreExport void HoldTrack();

        Class_ID ClassID() {return Class_ID(NOTETRACK_CLASS_ID,0);}

        // Tree view methods from animatable
        int NumKeys() {return keys.Count();}
        TimeValue GetKeyTime(int index) {return keys[index]->time;}
        CoreExport void MapKeys(TimeMap *map,DWORD flags );
        CoreExport void DeleteKeys( DWORD flags );
        CoreExport void CloneSelectedKeys(BOOL offset);     
        CoreExport void DeleteTime( Interval iv, DWORD flags );
        CoreExport void ReverseTime( Interval iv, DWORD flags );
        CoreExport void ScaleTime( Interval iv, float s);
        CoreExport void InsertTime( TimeValue ins, TimeValue amount );
        CoreExport void AddNewKey(TimeValue t,DWORD flags);
        CoreExport int GetSelKeyCoords(TimeValue &t, float &val,DWORD flags);
        CoreExport void SetSelKeyCoords(TimeValue t, float val,DWORD flags);
        #pragma warning(push)
        #pragma warning(disable:4100)
        CoreExport int GetTrackVSpace( int lineHeight ) {return 1;}
        CoreExport BOOL CanCopyTrack(Interval iv,DWORD flags) {return 1;}
        CoreExport BOOL CanPasteTrack(TrackClipObject *cobj,Interval iv,DWORD flags) {return cobj->ClassID()==ClassID();}
        CoreExport TrackClipObject *CopyTrack(Interval iv,DWORD flags);
        CoreExport void PasteTrack(TrackClipObject *cobj,Interval iv,DWORD flags);
        CoreExport Interval GetTimeRange(DWORD flags) ;     
        CoreExport int HitTestTrack(TrackHitTab& hits,Rect& rcHit,Rect& rcTrack,float zoom,int scroll,DWORD flags );
        CoreExport int PaintTrack(ParamDimensionBase *dim,HDC hdc,Rect& rcTrack,Rect& rcPaint,float zoom,int scroll,DWORD flags );
        CoreExport void SelectKeys( TrackHitTab& sel, DWORD flags );
        CoreExport void SelectKeyByIndex(int i,BOOL sel);
        CoreExport int NumSelKeys();
        CoreExport void FlagKey(TrackHitRecord hit);
        CoreExport int GetFlagKeyIndex();       
        CoreExport BOOL IsAnimated() {return TRUE;}
        CoreExport void EditTrackParams(TimeValue t,ParamDimensionBase *dim,MCHAR *pname,HWND hParent,IObjParam *ip,DWORD flags);
        CoreExport int TrackParamsType() {return TRACKPARAMS_KEY;}
        CoreExport BOOL SupportTimeOperations() {return TRUE;}

        CoreExport IOResult Save(ISave *isave);
        CoreExport IOResult Load(ILoad *iload);

        CoreExport void DeleteThis();
        RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget,
             PartID& partID, RefMessage message) {return REF_SUCCEED;}
        #pragma warning(pop)
        CoreExport RefTargetHandle Clone(RemapDir &remap);
    };