INodeExposure.h

Go to the documentation of this file.

/**********************************************************************
 
    FILE: INodeExposure.h

    DESCRIPTION:  Public interface for determining if a node should be
                    exposed in misc. UIs (SelectObjects, TrackView etc).

    CREATED BY: Oleg Bayborodin

    HISTORY: - created March 21, 2002

 *> Copyright (c) 1998-2002, All Rights Reserved.
 **********************************************************************/

#pragma once

#include "iFnPub.h"
#include "maxtypes.h"
#include "inode.h"

#define NODEEXPOSURE_INTERFACE Interface_ID(0x1b00412c, 0x6ebf48f2)
#define NODEEXPOSURE_INTERFACE_TOAPPEND Interface_ID(0x1b00412c, 0x6ebf48f3)


class INodeExposure : public FPMixinInterface {
public:

enum {  
        kSelectObjects, kSchematicView,     kMaxscript,
        kMerge,         kMergeAnimation,    kReplace, 
        kKeyEditor,     kCurveEditor,       kRangeEditor, // three components for TrackView editors
        kUI_num // always last in the enum
    };

    // Utilities:
    static INodeExposure* GetINodeExposure(INode& n) {
        return static_cast<INodeExposure*>(n.GetInterface(NODEEXPOSURE_INTERFACE)); }

    static INodeExposure* AppendINodeExposure(INode& n) {
        return static_cast<INodeExposure*>(n.GetInterface(NODEEXPOSURE_INTERFACE_TOAPPEND)); }

    // exposure in a specific UI
    virtual bool IsExposed(int ui) const =0;
    // set exposure in all UIs
    virtual void SetExposed(bool state) =0;
    // set exposure in a specific UI
    virtual void SetExposed(bool state, int ui) =0;

    // Derived methods. They are all inline'd at the end of the file.
    bool IsExposedInSelectObjects() const;
    bool IsExposedInSchematicView() const;
    bool IsExposedInMaxscript() const;
    bool IsExposedInMerge() const;
    bool IsExposedInMergeAnimation() const;
    bool IsExposedInReplace() const;
    bool IsExposedInTrackView() const;
    bool IsExposedInKeyEditor() const;
    bool IsExposedInCurveEditor() const;
    bool IsExposedInRangeEditor() const;
    void SetExposedInSelectObjects(bool state);
    void SetExposedInSchematicView(bool state);
    void SetExposedInMaxscript(bool state);
    void SetExposedInMerge(bool state);
    void SetExposedInMergeAnimation(bool state);
    void SetExposedInReplace(bool state);
    void SetExposedInTrackView(bool state);
    void SetExposedInKeyEditor(bool state);
    void SetExposedInCurveEditor(bool state);
    void SetExposedInRangeEditor(bool state);
    
    virtual IOResult    Save(ISave*) const =0;
    virtual IOResult    Load(ILoad*) =0;
    virtual void        Copy(INodeExposure*) =0;

    // makes exposure parameters to be permanent (not mutable)
    virtual void BakeExposure() =0;
    // defines if exposure is baked
    virtual bool IsExposureBaked() =0;

    // Used by implementation class:
    virtual const void* ObjectOf(void*) const =0;
    virtual       void* ObjectOf(void*) =0;

    // Due to FPMixinInterface:
    FPInterfaceDesc* GetDesc() { return GetDescByID(NODEEXPOSURE_INTERFACE); }

    // Function publishings:
    //
    enum FuncID {
        kIsExposed, kSetExposedInAll, kSetExposed, kBakeExposure
    };

BEGIN_FUNCTION_MAP
    FN_1(kIsExposed,    TYPE_bool,  IsExposed,  TYPE_INT);
    VFN_1(kSetExposedInAll,         SetExposed, TYPE_bool);
    VFN_2(kSetExposed,              SetExposed, TYPE_bool, TYPE_INT);
    VFN_0(kBakeExposure,            BakeExposure );
END_FUNCTION_MAP

};

// inlines for derived methods
//
inline bool INodeExposure::IsExposedInSelectObjects() const
{
    return IsExposed(kSelectObjects);
}

inline bool INodeExposure::IsExposedInSchematicView() const
{
    return IsExposed(kSchematicView);
}

inline bool INodeExposure::IsExposedInMaxscript() const
{
    return IsExposed(kMaxscript);
}

inline bool INodeExposure::IsExposedInMerge() const
{
    return IsExposed(kMerge);
}

inline bool INodeExposure::IsExposedInMergeAnimation() const
{
    return IsExposed(kMergeAnimation);
}

inline bool INodeExposure::IsExposedInReplace() const
{
    return IsExposed(kReplace);
}

inline bool INodeExposure::IsExposedInTrackView() const
{
    return (IsExposed(kKeyEditor) || IsExposed(kCurveEditor) || IsExposed(kRangeEditor));
}

inline bool INodeExposure::IsExposedInKeyEditor() const
{
    return IsExposed(kKeyEditor);
}

inline bool INodeExposure::IsExposedInCurveEditor() const
{
    return IsExposed(kCurveEditor);
}

inline bool INodeExposure::IsExposedInRangeEditor() const
{
    return IsExposed(kRangeEditor);
}

inline void INodeExposure::SetExposedInSelectObjects(bool state)
{
    SetExposed(state, kSelectObjects);
}

inline void INodeExposure::SetExposedInSchematicView(bool state)
{
    SetExposed(state, kSchematicView);
}

inline void INodeExposure::SetExposedInMaxscript(bool state)
{
    SetExposed(state, kMaxscript);
}

inline void INodeExposure::SetExposedInMerge(bool state)
{
    SetExposed(state, kMerge);
}

inline void INodeExposure::SetExposedInMergeAnimation(bool state)
{
    SetExposed(state, kMergeAnimation);
}

inline void INodeExposure::SetExposedInReplace(bool state)
{
    SetExposed(state, kReplace);
}

inline void INodeExposure::SetExposedInTrackView(bool state)
{
    SetExposed(state, kKeyEditor);
    SetExposed(state, kCurveEditor);
    SetExposed(state, kRangeEditor);
}

inline void INodeExposure::SetExposedInKeyEditor(bool state)
{
    SetExposed(state, kKeyEditor);
}

inline void INodeExposure::SetExposedInCurveEditor(bool state)
{
    SetExposed(state, kCurveEditor);
}

inline void INodeExposure::SetExposedInRangeEditor(bool state)
{
    SetExposed(state, kRangeEditor);
}