ref.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:        ref.h
// DESCRIPTION: Defines reference system classes
// AUTHOR:      Rolf Berteig & Dan Silva
// HISTORY:     created 9 September 1994
//**************************************************************************/

#pragma once
#include "BuildWarnings.h"
#include "maxheap.h"
#include "strbasic.h"
#include "noncopyable.h"
#include "autoptr.h"
#include <WTypes.h> // for ULONG_PTR
#include "CoreExport.h"
#include "Animatable.h"
#include "AnimatableFlags.h"
#include "hold.h" // for RestoreObj
#include "channels.h" // for ALL_CHANNELS

/* This module implements a first run at the concept of references.
Some other stuff is in here too like time and intervals, but
these are implemented only to get the reference classes working. */

typedef void* ReferenceData;
typedef unsigned int TargetParam;

//==============================================================================
//  Part ID's
//==============================================================================

    
typedef ULONG_PTR PartID;


#define PART_TOPO           TOPO_CHANNEL

#define PART_GEOM           GEOM_CHANNEL 

#define PART_TEXMAP         TEXMAP_CHANNEL

#define PART_MTL            MTL_CHANNEL  

#define PART_SELECT         SELECT_CHANNEL

#define PART_SUBSEL_TYPE    SUBSEL_TYPE_CHANNEL

#define PART_DISPLAY        DISP_ATTRIB_CHANNEL

#define PART_VERTCOLOR      VERTCOLOR_CHANNEL

#define PART_GFX_DATA       GFX_DATA_CHANNEL

#define PART_DISP_APPROX    DISP_APPROX_CHANNEL

#define PART_EXTENSION      EXTENSION_CHANNEL

#define PART_TM_CHAN        TM_CHANNEL

#define PART_MTL_CHAN       GLOBMTL_CHANNEL

#define PART_OBJECT_TYPE    (1<<11)      

#define PART_TM             (1<<12)

#define PART_OBJ            (PART_TOPO|PART_GEOM)

#define PART_ALL            (ALL_CHANNELS|PART_TM)


#define PART_GI_EXCLUDED                (1<<0)
#define PART_GI_OCCLUDER                (1<<1)
#define PART_GI_RECEIVER                (1<<2)
#define PART_GI_DIFFUSE             (1<<3)
#define PART_GI_SPECULAR                (1<<4)
#define PART_GI_NBREFINESTEPS           (1<<5)
#define PART_GI_MESHSIZE                (1<<6)
#define PART_GI_MESHINGENABLED          (1<<7)
#define PART_GI_USEGLOBALMESHING        (1<<8)
#define PART_GI_EXCLUDEFROMREGATHERING  (1<<9)
#define PART_GI_STOREILLUMMESH          (1<<10)
#define PART_GI_RAYMULT                 (1<<11)
#define PART_GI_USE_ADAPTIVE_SUBDIVISION (1<<12)
#define PART_GI_MIN_MESH_SIZE           (1<<13)
#define PART_GI_INITIAL_MESH_SIZE       (1<<14)
#define PART_GI_CONTRAST_THRESHOLD      (1<<15)


// ASzabo|june.04.03
#define PART_REND_PROP_RENDERABLE                   (1<<0)
#define PART_REND_PROP_CAST_SHADOW                  (1<<1)
#define PART_REND_PROP_RCV_SHADOW                   (1<<2)
#define PART_REND_PROP_RENDER_OCCLUDED              (1<<3)
#define PART_REND_PROP_VISIBILITY                   (1<<4)
#define PART_REND_PROP_INHERIT_VIS                  (1<<5)
#define PART_REND_PROP_PRIMARY_INVISIBILITY         (1<<6)
#define PART_REND_PROP_SECONDARY_INVISIBILITY       (1<<7)


#define PART_DISP_PROP_IS_HIDDEN                    (1<<0)
#define PART_DISP_PROP_IS_FROZEN                    (1<<1)
#define PART_DISP_PROP_SHOW_FRZN_WITH_MTL           (1<<2)
#define PART_DISP_PROP_BOX_MODE                     (1<<3)
#define PART_DISP_PROP_BACKCULL                     (1<<4)
#define PART_DISP_PROP_ALL_EDGES                    (1<<5)
#define PART_DISP_PROP_BONE_ONLY                    (1<<6)
#define PART_DISP_PROP_BONE_AS_LINE                 (1<<7)
#define PART_DISP_PROP_SHOW_PATH                    (1<<8)
#define PART_DISP_PROP_VERT_TICKS                   (1<<9)
#define PART_DISP_PROP_XRAY_MTL                     (1<<10)
#define PART_DISP_PROP_IGNORE_EXTENTS               (1<<11)
#define PART_DISP_PROP_COLOR_VERTS                  (1<<12)



#define PART_EXCLUDE_RADIOSITY (1<<29)


#define PART_HIDESTATE      (1<<30)


#define PART_MXS_PROPCHANGE         (1<<16)


#define PART_PUT_IN_FG              (1<<0)

#define PART_SHOW_DEPENDENCIES      (1<<1)

#define PART_SHOWDEP_ON             (1<<2)





typedef unsigned int RefMessage;

#define REFMSG_LOOPTEST                 0x00000010


#define REFMSG_TARGET_DELETED           0x00000020

#define REFMSG_MODAPP_DELETING          0x00000021

#define REFMSG_EVAL                     0x00000030

#define REFMSG_RESET_ORIGIN             0x00000040


#define REFMSG_CHANGE                   0x00000050

#define REFMSG_FLAGDEPENDENTS           0x00000070

#define REFMSG_TARGET_SELECTIONCHANGE   0x00000080


#define REFMSG_BEGIN_EDIT               0x00000090


#define REFMSG_END_EDIT                 0x000000A0

#define REFMSG_DISABLE                  0x000000B0

#define REFMSG_ENABLE                   0x000000C0

#define REFMSG_TURNON                   0x000000D0

#define REFMSG_TURNOFF                  0x000000E0

#define REFMSG_LOOKAT_TARGET_DELETED    0x000000F0 

#define REFMSG_INVALIDATE_IF_BG         0x000000F1


#define REFMSG_MOD_DISPLAY_ON           0x000000F2


#define REFMSG_MOD_DISPLAY_OFF          0x000000F3


#define REFMSG_MOD_EVAL                 0x000000F4


#define REFMSG_IS_OK_TO_CHANGE_TOPOLOGY 0x000000F5


// This main purpose of these notifications is to cause the tree
// view to update when one of these events takes place.

#define REFMSG_NODE_LINK                0x000000F6


#define REFMSG_NODE_NAMECHANGE          0x000000F7


#define REFMSG_OBREF_CHANGE             0x000000F8

#define REFMSG_MODIFIER_ADDED           0x000000F9

#define REFMSG_CONTROLREF_CHANGE        0x000000FA

//*! \ref partids is set to a pointer to a GetParamName structure defined in iparamb.h */
#define REFMSG_GET_PARAM_NAME           0x000000FB


#define REFMSG_GET_PARAM_DIM            0x000000FC

#define REFMSG_GET_CONTROL_DIM          0x000000FD


#define REFMSG_TM_CHANGE                0x000000FE

#define REFMSG_RANGE_CHANGE             0x000000FF

#define REFMSG_LINEHEIGHT_CHANGE        0x00000100


#define REFMSG_BECOMING_ANIMATED        0x00000101


#define REFMSG_SUBANIM_STRUCTURE_CHANGED 0x00000102

/* Materials use this to tell the material whether or not the number of node
references has gone to zero. */
#define REFMSG_REF_DELETED          0x00000103

/* Materials use this to tell the material whether or not the number of node
references are non zero.*/
#define REFMSG_REF_ADDED            0x00000104

#define REFMSG_BRANCHED_HISTORY_CHANGED 0x00000105


#define REFMSG_NODEINSELSET_CHANGED 0x00000106


#define REFMSG_TEST_DEPENDENCY  0x00000107


#define REFMSG_WANT_SHOWPARAMLEVEL  0x00000108


#define REFMSG_BEFORE_PASTE     0x00000109


#define REFMSG_NOTIFY_PASTE     0x0000010A

#define REFMSG_UV_SYM_CHANGE    0x0000010B


#define REFMSG_GET_NODE_NAME            0x0000010C

#define REFMSG_SEL_NODES_DELETED        0x0000010D

#define REFMSG_PRENOTIFY_PASTE  0x0000010E


#define REFMSG_SHAPE_START_CHANGE   0x0000010F

#define REFMSG_SHAPE_END_CHANGE     0x00000110


#define REFMSG_TEXMAP_REMOVED   0x00000111


#define REFMSG_FLAG_NODES_WITH_SEL_DEPENDENTS   0x00000112

#define REFMSG_CONTAINED_SHAPE_POS_CHANGE 0x00000120

#define REFMSG_CONTAINED_SHAPE_SEL_CHANGE 0x00000121

#define REFMSG_CONTAINED_SHAPE_GENERAL_CHANGE 0x00000122


#define REFMSG_SELECT_BRANCH    0x00000130


#define REFMSG_MOUSE_CYCLE_STARTED      0x00000140

#define REFMSG_MOUSE_CYCLE_COMPLETED    0x00000150


#define REFMSG_CHECK_FOR_INVALID_BIND   0x00000161


#define REFMSG_OBJECT_CACHE_DUMPED  0x00000162


#define REFMSG_SFX_CHANGE       0x00000170


#define REFMSG_OBJXREF_UPDATEMAT    0x00000180


#define REFMSG_OBJXREF_UPDATECTRL   0x00000181



#define REFMSG_OBJXREF_GETNODES         0x00000190


#define REFMSG_CTRLXREF_GETNODES        0x00000191


#define REFMSG_MTLXREF_GETNODES         0x00000192



#define REFMSG_OBJECT_REPLACED      0x00000200

#define REFMSG_NODE_WIRECOLOR_CHANGED 0x00000210

#define REFMSG_NUM_SUBOBJECTTYPES_CHANGED 0x00000211


#define REFMSG_GET_NODE_HANDLE          0x00000220

#define REFMSG_END_MODIFY_PARAMS    0x00000230

#define REFMSG_BEGIN_MODIFY_PARAMS 0x00000231


#define REFMSG_TAB_ELEMENT_NULLED 0x00000232


#define REFMSG_NODE_HANDLE_CHANGED 0x00000233


#define REFMSG_NODE_WSCACHE_UPDATED 0x00000234

#define REFMSG_NODE_MATERIAL_CHANGED    0x00000235


#define REFMSG_SUBANIM_NUMBER_CHANGED    0x00000236   


#define REFMSG_NODE_FLAGOMB_RENDER 0x00000237 

// 

#define REFMSG_NODE_GI_PROP_CHANGED 0x00000238

#define REFMSG_KEY_SELECTION_CHANGED 0x00000239

// ASzabo|june.04.03
#define REFMSG_NODE_RENDERING_PROP_CHANGED  0x00000240


#define REFMSG_NODE_DISPLAY_PROP_CHANGED    0x00000241


#define REFMSG_MXS_CUSTATTRIB_CHANGE 0x00000250


#define REFMSG_NODE_PRE_DELETE          0x00000255


#define REFMSG_LOCKED               0x00000260

#define REFMSG_UNLOCKED                 0x00000261


#define REFMSG_OBJECT_DEFINITION_CHANGE_BEGIN               0x00000270


#define REFMSG_OBJECT_DEFINITION_CHANGE_END                 0x00000271

#define REFMSG_USER     0x00010000


// JBW 9.9.00 



#define TARGETMSG_USER              0x00010000

#define TARGETMSG_ATTACHING_NODE    0x00000010      

#define TARGETMSG_DELETING_NODE     0x00000020      


#define TARGETMSG_DETACHING_NODE    0x00000030




enum RefResult {
    REF_FAIL = 0,
    REF_HALT = 0,
    REF_SUCCEED,
    REF_DONTCARE,
    REF_STOP,
    REF_INVALID,
    REF_AUTO_DELETE
};

class ReferenceTarget;
typedef ReferenceTarget* RefTargetHandle;

class ReferenceMaker;
typedef ReferenceMaker* RefMakerHandle;

// This replaces the .Valid() method of handles.
#define VALID(x) (x)

#define NOTIFY_ALL      0xfffffff0

class PostPatchProc;


class RemapDir: public MaxHeapOperators {
    public:


        virtual RefTargetHandle FindMapping(RefTargetHandle from) = 0;


        virtual RefTargetHandle CloneRef(RefTargetHandle oldTarg);


        virtual void PatchPointer(RefTargetHandle* patchThis, RefTargetHandle oldTarg) = 0;
        

        virtual void AddPostPatchProc(PostPatchProc* proc, bool toDelete) = 0;



        /* This method is used to register the mapping of an object to the clone
        of the object. This method is called by CloneRef and by 
        ReferenceTarget::BaseClone, and so does not normally need to be
        called from plugins. One exception is for code similar to the following:
        \code 
        PRSControl& PRSControl::operator=(const PRSControl& ctrl) {
            RemapDir *remap = NewRemapDir();
            ReplaceReference(PRS_POS_REF,remap->CloneRef(ctrl.pos));
            ReplaceReference(PRS_ROT_REF,remap->CloneRef(ctrl.rot));
            ReplaceReference(PRS_SCL_REF,remap->CloneRef(ctrl.scl));

            // Make sure that if any sub-controller references this 
            // controller that it will get backpatched correctly  
            remap->AddEntry(ctrl,this);
            remap->DeleteThis();
            mLocked = ctrl.mLocked;
            return(*this);
        }
        \endcode 

        \param  hfrom - The item that was cloned.
        \param  hto - The clone of the item.
        */
        virtual void AddEntry(RefTargetHandle hfrom, RefTargetHandle hto)=0;
        /* This method first runs any back patch procedures the RemapDir registered
        (see PatchPointer) and then any PostPatchProcs that were registered (see
        AddPostPatchProc).
        This method is run by the RemapDir as it is being deleted, and so does not 
        normally need to be called from plugins.
        */
        virtual void Backpatch()=0;
        virtual bool BackpatchPending()=0;
        virtual void Clear()=0;
        virtual void ClearBackpatch()=0;
        virtual void DeleteThis()=0;
        virtual ~RemapDir() {}
};

class PostPatchProc: public MaxHeapOperators {
public:
    virtual ~PostPatchProc(){}
    virtual int Proc(RemapDir& remap) = 0;
};

class DeleteRefRestore;
class MakeRefRestore;
class ParamBlock;
class ISave;
class ILoad;
class ILoadImp;
class DependentIterator;



#define DEP_ENUM_CONTINUE   0

#define DEP_ENUM_HALT       1

#define DEP_ENUM_SKIP       2   



class DependentEnumProc: public MaxHeapOperators {

    friend class ReferenceTarget;
    friend class ReferenceMaker;

    class DependentEnumProcImplData;
    const MaxSDK::Util::AutoPtr<DependentEnumProcImplData> mDependentEnumProcImplData;

protected:
    CoreExport DependentEnumProc();
    CoreExport virtual ~DependentEnumProc();

    // Hide it - no copy constructor or assignment to the public.
    DependentEnumProc(const DependentEnumProc&); // not implemented
    DependentEnumProc& operator=(const DependentEnumProc& rhs); // not implemented

public:

        virtual int proc(ReferenceMaker *rmaker)=0;


        CoreExport bool CheckIfAndSetAsVisited(ReferenceMaker *rmaker);

    };


class SaveEnumProc: public MaxHeapOperators {
    public:

        virtual void proc(ReferenceMaker *rmaker)=0;

        virtual int terminate(ReferenceMaker *rmaker)=0; 
    };



class DefaultRemapDir: public RemapDir
{
private:
    const MaxSDK::Util::AutoPtr<RemapDir> mRemapDir;
    // Copy construction and assignment of objects of this class is disallowed
    DefaultRemapDir(const DefaultRemapDir& aDefaultRemapDir); // not implemented
    DefaultRemapDir& operator=(const DefaultRemapDir& rhs); // not implemented
public:
    CoreExport DefaultRemapDir(BOOL use_A_WORK2_flag = FALSE);
    CoreExport ~DefaultRemapDir();
    RefTargetHandle FindMapping(RefTargetHandle from);
    void AddEntry(RefTargetHandle hfrom, RefTargetHandle hto);
    void PatchPointer(RefTargetHandle* patchThis, RefTargetHandle oldTarg);
    void Backpatch();
    bool BackpatchPending();
    void Clear();
    void ClearBackpatch();
    void DeleteThis();
    void AddPostPatchProc(PostPatchProc* proc, bool toDelete);
};


CoreExport RemapDir* NewRemapDir(BOOL use_A_WORK2_flag=FALSE); 

#define REFERENCE_MAKER_INTERFACE 0x2f96f73

#define REFERENCE_TARGET_INTERFACE 0x66b073ea

class RefEnumProc;
class ReferenceSaveManager;


class ReferenceMaker : public Animatable {
    friend class DeleteRefRestore;
    friend class MakeRefRestore;
    friend class ReferenceTarget;
    friend class ParamBlock;
    friend class RootNode;
    friend class BaseNode;
    friend class ILoadImp;
    friend class RefMakerPLC;
    friend class RefList;
    
    // temporary friend declarations until figure out what the code there is doing
    friend class LayerManagerRestore; 
    friend class RepMtlRest;  
    friend class MAXMaterialLibrary;  


    protected:

        CoreExport virtual ~ReferenceMaker() = 0;

    public:
        CoreExport ReferenceMaker();


        CoreExport void DeleteMe();

        virtual void GetClassName(MSTR& s) { s = _M("ReferenceMaker"); }
        CoreExport virtual SClass_ID SuperClassID();




        CoreExport RefResult ReplaceReference(
            int which, 
            RefTargetHandle newtarg, 
            BOOL delOld = TRUE);


        CoreExport RefResult DeleteAllRefsFromMe();
            

        virtual RefResult DeleteAllRefsToMe() { return REF_SUCCEED; }
            

        CoreExport RefResult DeleteAllRefs();


        CoreExport RefResult DeleteReference( int i);


        virtual BOOL CanTransferReference(int i) { UNUSED_PARAM(i); return TRUE; }




        CoreExport virtual int NumRefs();


        CoreExport virtual RefTargetHandle GetReference(int i);
protected:  

        CoreExport virtual void SetReference(int i, RefTargetHandle rtarg);

public:



        CoreExport ReferenceSaveManager& GetReferenceSaveManager();


        CoreExport virtual IOResult Save(ISave *isave);
        

        CoreExport virtual IOResult Load(ILoad *iload);


        virtual int RemapRefOnLoad(int iref) { return iref; }


        CoreExport virtual void RescaleWorldUnits(float f);




        CoreExport virtual RefResult NotifyDependents(
            Interval changeInt, 
            PartID partID, 
            RefMessage message, 
            SClass_ID sclass = NOTIFY_ALL,
            BOOL propagate = TRUE, 
            RefTargetHandle hTarg = NULL);




        CoreExport virtual void EnumAuxFiles(AssetEnumCallback& assetEnum, DWORD flags);


        CoreExport virtual void SaveEnum(SaveEnumProc& sep, BOOL isNodeCall = 0);


        CoreExport virtual bool SpecifySaveReferences(ReferenceSaveManager& referenceSaveManager);





        CoreExport int DoEnumDependents(DependentEnumProc* dep);


        CoreExport virtual int DoEnumDependentsImpl(DependentEnumProc* dep);


        CoreExport bool EnumRefHierarchy(
            RefEnumProc &proc, 
            bool includeCustAttribs = true, 
            bool includeIndirectRefs = true, 
            bool includeNonPersistentRefs = true, 
            bool preventDuplicatesViaFlag = true);




        CoreExport int FindRef(RefTargetHandle rtarg);


        virtual BOOL IsRefTarget() { return FALSE; }


        virtual BOOL IsRefMaker() { return TRUE; }


        virtual BOOL IsRealDependency(ReferenceTarget *rtarg) { UNUSED_PARAM(rtarg); return TRUE;}


        virtual BOOL ShouldPersistWeakRef(RefTargetHandle rtarg) { UNUSED_PARAM(rtarg); return FALSE; }




        CoreExport virtual void* GetInterface(ULONG id);


        CoreExport virtual BaseInterface* GetInterface(Interface_ID id);

    protected:

        void BlockEval()    {   SetAFlag(A_EVALUATING); }
        void UnblockEval()  { ClearAFlag(A_EVALUATING); }       
        int Evaluating()    { return TestAFlag(A_EVALUATING); }     
        
        CoreExport RefResult StdNotifyRefChanged(
            Interval changeInt, 
            RefTargetHandle hTarget, 
            PartID partID, 
            RefMessage message, 
            BOOL propagate = TRUE);




            virtual RefResult NotifyRefChanged(
                Interval changeInt, 
                RefTargetHandle hTarget, 
                PartID& partID,  
                RefMessage message) = 0;

    private:

        void CheckForNonNullRefsOnInitialization(int ignoreRef = -1);       

        /* \param which - the index of the reference link to verify
        \return - Returns true if either the reference is NULL or correctly set up.
        Returns false if the reference target does not know of this reference maker.
        */
        bool ValidateExistingReference(int which);      

        bool EnumRefHierarchyImpl(
            RefEnumProc &proc, 
            bool includeCustAttribs, 
            bool includeIndirectRefs, 
            bool includeNonPersistentRefs);

        void AddReference(AnimHandle hTarget);
        void RemoveReference(AnimHandle hTarget);


        class ReferenceMakerImplData;
        const MaxSDK::Util::AutoPtr<ReferenceMakerImplData> mImplData;
};

#pragma warning(push)
#pragma warning(disable:4239)


class ReferenceTarget : public ReferenceMaker {
    friend class DependentIterator;
    friend class DeleteRefRestore;
    friend class MakeRefRestore;
    friend class ReferenceMaker;
    class RefList;


    protected:

        CoreExport virtual ~ReferenceTarget() = 0; 

    public:
        CoreExport ReferenceTarget();


        CoreExport virtual RefResult AutoDelete();


        CoreExport RefResult MaybeAutoDelete();

        CoreExport virtual void GetClassName(MSTR& s);  
        CoreExport virtual SClass_ID SuperClassID();




        virtual BOOL IsRefTarget() { return TRUE; }


        CoreExport RefResult TestForLoop( Interval refInterval, RefMakerHandle hmaker);


        CoreExport BOOL HasDependents();


        CoreExport BOOL HasRealDependents();  // not counting tree view


        void BeginDependencyTest() { ClearAFlag(A_DEPENDENCY_TEST); }


        BOOL EndDependencyTest() { return TestAFlag(A_DEPENDENCY_TEST); }




        virtual void RefAdded(RefMakerHandle rm) { UNUSED_PARAM(rm); }


        virtual void RefAddedUndoRedo(RefMakerHandle rm) { UNUSED_PARAM(rm); }

        // This is called after deleting a reference to a ref target,
        // in the case that the target was not deleted. If target needs
        // to know, it should override this method.

        virtual void RefDeleted() {}


        virtual void RefDeletedUndoRedo() {}
        

        CoreExport RefResult DeleteAllRefsToMe();


        CoreExport RefResult TransferReferences(
            RefTargetHandle oldTarget, 
            BOOL delOld = FALSE);


        // 

        CoreExport int DoEnumDependents(DependentEnumProc* dep);    



        CoreExport virtual RefTargetHandle Clone(RemapDir& remap);


        CoreExport virtual void BaseClone(
            ReferenceTarget *from, 
            ReferenceTarget *to,
            RemapDir &remap);
        



        CoreExport virtual RefResult NotifyDependents(
            Interval changeInt, 
            PartID partID, 
            RefMessage message, 
            SClass_ID sclass = NOTIFY_ALL,
            BOOL propagate = TRUE, 
            RefTargetHandle hTarg = NULL);
 

        void FlagDependents( TimeValue t, PartID which=PART_PUT_IN_FG ) { 
            NotifyDependents( Interval(t,t), which, REFMSG_FLAGDEPENDENTS );
        }


        virtual void NotifyForeground(TimeValue t) {
            NotifyDependents(Interval(t,t),PART_PUT_IN_FG,REFMSG_FLAGDEPENDENTS);
        }


        virtual void NotifyTarget(int message, ReferenceMaker* hMaker) { UNUSED_PARAM(message); UNUSED_PARAM(hMaker); }




        CoreExport virtual void* GetInterface(ULONG id);


        CoreExport virtual BaseInterface* GetInterface(Interface_ID id);

    protected:
        // 

        CoreExport virtual int DoEnumDependentsImpl(DependentEnumProc* dep);

    private:
        // Redeclared as private because it should not be called directly by plugins
        using ReferenceMaker::NotifyRefChanged;


        CoreExport RefResult MakeReference(
            Interval refInterval,
            RefMakerHandle hmaker,
            int whichRef = -1);

    private:

        class RefListItem: public MaxSDK::Util::Noncopyable 
        {
        public:
            ReferenceMaker* mMaker;
            RefListItem* mNext;
            RefListItem( ReferenceMaker* maker, RefListItem *list );
            ~RefListItem();
        };


        class RefList: public MaxSDK::Util::Noncopyable 
        {
            friend class ReferenceTarget;
            friend class DependentIterator;
        public:
            RefList();

            ~RefList();

            RefListItem* FirstItem() const;


            RefResult DeleteItem(ReferenceMaker* maker, int eval);


            RefResult AddItem(ReferenceMaker* maker);

            bool Empty() const;

        private: // methods
            void SetOwner(ReferenceTarget& owner);

            void RemoveEmptyListItems();

            // the owner of this list.
            bool CleanupReferences();

        private: // data members
            RefListItem* mFirst;    
            AnimHandle mOwnerRefTarget;
            bool mHasEmptyListItems;
        };

        RefList* mRefs;
};

#pragma warning(pop)

// Forward declaration
namespace MaxSDK
{
    class SingleWeakRefMaker;
};


class DependentIterator: public MaxSDK::Util::Noncopyable 
{
public:

    CoreExport DependentIterator(ReferenceTarget* rtarg);
    CoreExport ~DependentIterator();
    CoreExport ReferenceMaker* Next();
    CoreExport void Reset(); 
    
private:
    // No default construction allowed
    DependentIterator();

private:
    ReferenceTarget* mTarget;
    ReferenceTarget::RefListItem* mNext;
};

class DeletedRestore : public RestoreObj
{
    RefMakerHandle anim, svanim;
public:
    CoreExport DeletedRestore();
    CoreExport DeletedRestore(RefMakerHandle an);
    CoreExport ~DeletedRestore();
    CoreExport void Restore(int isUndo);
    CoreExport void Redo();
    CoreExport MSTR Description();
};



#define REF_ENUM_CONTINUE   0

#define REF_ENUM_HALT       1

#define REF_ENUM_SKIP       2   



class RefEnumProc: public MaxHeapOperators
{
    friend class ReferenceTarget;
    class RefEnumProcImplData;
    const MaxSDK::Util::AutoPtr<RefEnumProcImplData> mRefEnumProcImplData;

protected:
    CoreExport RefEnumProc();
    CoreExport virtual ~RefEnumProc();

    // Hide it - no copy constructor or assignment to the public.
    RefEnumProc(const RefEnumProc&); // not implemented
    RefEnumProc& operator=(const RefEnumProc& rhs); // not implemented

    public:

    virtual int proc(ReferenceMaker *rm)=0;


    CoreExport virtual bool CheckIfAndSetAsVisited(ReferenceMaker *rmaker);


    CoreExport void BeginEnumeration(bool preventDuplicatesViaFlag = true);


    CoreExport void EndEnumeration();
};


CoreExport ReferenceTarget *CloneRefHierarchy(ReferenceTarget *rm);



class GlobalReferenceMaker : public MaxHeapOperators
{
public:
    virtual ~GlobalReferenceMaker() {}
    class GlobalReferenceDisableGuard;


    virtual RefResult NotifyRefChanged(
        Interval iv, 
        RefTargetHandle hTarg,
        PartID& partID, 
        RefMessage msg) = 0;        
};


class GlobalReferenceMaker::GlobalReferenceDisableGuard : public MaxHeapOperators
{
public:

    CoreExport static bool IsDisabled();


    CoreExport GlobalReferenceDisableGuard(bool doDisable = true);


    CoreExport ~GlobalReferenceDisableGuard();

private:

    static int m_disableCount;

    bool m_doDisable;
};


CoreExport void RegisterGlobalReference(GlobalReferenceMaker *maker);


CoreExport void UnRegisterGlobalReference(GlobalReferenceMaker *maker);


CoreExport void ClearAFlagInHierarchy(RefMakerHandle rm, DWORD mask);


CoreExport void ClearAFlagInAllAnimatables(DWORD mask);


CoreExport BOOL DependsOn(RefMakerHandle mkr, RefMakerHandle targ);


CoreExport DWORD GetSavingVersion(); 

CoreExport DWORD SetSavingVersion(DWORD version); 


CoreExport void DisableRefMsgs();

CoreExport void EnableRefMsgs();


class SingleRefMaker: public ReferenceMaker {
protected:
    RefTargetHandle rtarget;
public:
    CoreExport SingleRefMaker();

    CoreExport ~SingleRefMaker();


    CoreExport void SetRef(RefTargetHandle rt);

    CoreExport RefTargetHandle GetRef() const;


    CoreExport RefResult NotifyRefChanged(
        Interval changeInt,
        RefTargetHandle hTarget, 
        PartID& partID, 
        RefMessage message );
    CoreExport void DeleteThis();
    CoreExport  SClass_ID  SuperClassID();

    // Overrides From ReferenceMaker
    CoreExport  int NumRefs();
    CoreExport  RefTargetHandle GetReference(int i);
protected:
    CoreExport  virtual void SetReference(int i, RefTargetHandle rtarg);
public:
    CoreExport  BOOL CanTransferReference(int i);
};


class CoreExport AnimateSuspend: public MaxHeapOperators {
private:
    BOOL animateSuspended; 
    BOOL setKeyModeSuspended;
    BOOL macroRecSuspended;
    BOOL refMsgsSuspended;
public:

    AnimateSuspend(
        BOOL setKeyModeToo = FALSE, 
        BOOL macroRecToo = FALSE, 
        BOOL refMsgsToo = FALSE );
    void Resume();
    ~AnimateSuspend() {Resume ();}
};                    


class CoreExport SuspendAll: public MaxHeapOperators {
private:
    BOOL holdSuspended;
    BOOL macroRecSuspended;
    BOOL animateSuspended;
    BOOL setKeyModeSuspended;
    BOOL autoBackupSuspended;
    BOOL saveRequiredState;
    BOOL refMsgsSuspended;
    BOOL m_previousSaveRequiredState;
    BOOL m_previousAutoBackupState;
public:

    SuspendAll(
        BOOL holdState = FALSE, 
        BOOL macroRecorder = FALSE, 
        BOOL animateMode = FALSE, 
        BOOL setKeyMode = FALSE, 
        BOOL autoBackup = FALSE, 
        BOOL saveRequired = FALSE, 
        BOOL refMsgs = FALSE );
    void Resume();
    ~SuspendAll() {Resume ();}
};