CWE-ou-minkata/Sources/Tools/MaxComponent/plResponderAnim.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "HeadSpin.h"
#include "plResponderAnim.h"
#include "plResponderComponentPriv.h"
#include "resource.h"
#include "max.h"

#include "../MaxMain/plMaxNode.h"

#include "plAnimComponent.h"
#include "plAudioComponents.h"

#include "plMaxAnimUtils.h"
#include <vector>

// Needed for anim msg creation
#include "../pnKeyedObject/plKey.h"
#include "../plMessage/plAnimCmdMsg.h"
#include "plNotetrackAnim.h"

// Needed for sound msg creation
#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plAudioInterface.h"
#include "plAudible.h"
#include "../pnMessage/plSoundMsg.h"

#include "../MaxMain/plPlasmaRefMsgs.h"

enum
{
    kAnimComp,
    kAnimLoop,
    kAnimType,
    kAnimOwner,
    kAnimObject,
    kAnimObjectType,
};

class plResponderAnimProc;
extern plResponderAnimProc gResponderAnimProc;

ParamBlockDesc2 gResponderAnimBlock
(
    kResponderAnimBlk, _T("animCmd"), 0, NULL, P_AUTO_UI,

    IDD_COMP_RESPOND_ANIM, IDS_COMP_CMD_PARAMS, 0, 0, &gResponderAnimProc,

    kAnimComp,  _T("comp"),     TYPE_REFTARG,       0, 0,
        end,

    kAnimObject, _T("object"),  TYPE_REFTARG,       0, 0,
        end,

    kAnimLoop,  _T("loop"),     TYPE_STRING,        0, 0,
        end,

    kAnimType,  _T("type"),     TYPE_INT,           0, 0,
        end,

    kAnimObjectType,    _T("objType"),  TYPE_INT,   0, 0,
        end,

    end
);

enum AnimObjectType
{
    kNodePB,        // Use the node in the PB
    kNodeResponder  // Use the node the responder is attached to
};

plResponderCmdAnim& plResponderCmdAnim::Instance()
{
    static plResponderCmdAnim theInstance;
    return theInstance;
}

ParamBlockDesc2 *plResponderCmdAnim::GetDesc()
{
    return &gResponderAnimBlock;
}

// Use the old types, for backwards compatibility
enum 
{
    kRespondPlayAnim, 
    kRespondStopAnim, 
    kRespondToggleAnim, 
    kRespondLoopAnimOn,
    kRespondLoopAnimOff, 
    kRespondSetForeAnim=7,
    kRespondSetBackAnim,

    kRespondPlaySound,
    kRespondStopSound,
    kRespondToggleSound,
    kRespondSyncedPlaySound,

    kRespondPlayRndSound=19,
    kRespondStopRndSound,
    kRespondToggleRndSound,

    kRespondRewindAnim,
    kRespondRewindSound,
    kRespondFastForwardAnim,
    
    kNumTypes = 16
};

int plResponderCmdAnim::NumTypes()
{
    return kNumTypes;
}

static int IndexToOldType(int idx)
{
    static int oldTypes[] =
    {
        kRespondPlayAnim,
        kRespondStopAnim, 
        kRespondToggleAnim, 
        kRespondLoopAnimOn,
        kRespondLoopAnimOff, 
        kRespondSetForeAnim,
        kRespondSetBackAnim,

        kRespondPlaySound,
        kRespondStopSound,
        kRespondToggleSound,
        kRespondSyncedPlaySound,

        kRespondPlayRndSound,
        kRespondStopRndSound,
        kRespondToggleRndSound,

        kRespondRewindAnim,
        kRespondRewindSound,
        kRespondFastForwardAnim,
    };

    hsAssert(idx < kNumTypes, "Bad index");
    return oldTypes[idx];
}

const char *plResponderCmdAnim::GetCategory(int idx)
{
    int type = IndexToOldType(idx);

    switch (type)
    {
    case kRespondPlayAnim:
    case kRespondStopAnim:
    case kRespondToggleAnim:
    case kRespondLoopAnimOn:
    case kRespondLoopAnimOff:
    case kRespondSetForeAnim:
    case kRespondSetBackAnim:
    case kRespondRewindAnim:
    case kRespondFastForwardAnim:
        return "Animation";

    case kRespondPlaySound:
    case kRespondStopSound:
    case kRespondToggleSound:
    case kRespondRewindSound:
    case kRespondSyncedPlaySound:
        return "Sound";

    case kRespondPlayRndSound:
    case kRespondStopRndSound:
    case kRespondToggleRndSound:
        return "Random Sound";
    }

    return nil;
}

const char *plResponderCmdAnim::GetName(int idx)
{
    int type = IndexToOldType(idx);

    switch (type)
    {
    case kRespondPlayAnim:
    case kRespondPlaySound:
    case kRespondPlayRndSound:
        return "Play";

    case kRespondStopAnim:
    case kRespondStopSound:
    case kRespondStopRndSound:
        return "Stop";

    case kRespondToggleAnim:
    case kRespondToggleSound:
    case kRespondToggleRndSound:
        return "Toggle";

    case kRespondLoopAnimOn:
        return "Set Looping On";
    case kRespondLoopAnimOff:
        return "Set Looping Off";
    case kRespondSetForeAnim:
        return "Set Forwards";
    case kRespondSetBackAnim:
        return "Set Backwards";

    case kRespondRewindAnim:
    case kRespondRewindSound:
        return "Rewind";
    case kRespondFastForwardAnim:
        return "Fast Forward";
    case kRespondSyncedPlaySound:
        return "Synched Play";
    }

    return nil;
}

static const char *GetShortName(int type)
{
    switch (type)
    {
    case kRespondPlayAnim:          return "Anim Play";
    case kRespondStopAnim:          return "Anim Stop";
    case kRespondToggleAnim:        return "Anim Toggle";
    case kRespondLoopAnimOn:        return "Anim Loop On";
    case kRespondLoopAnimOff:       return "Anim Loop Off";
    case kRespondSetForeAnim:       return "Anim Set Fore";
    case kRespondSetBackAnim:       return "Anim Set Back";
    case kRespondPlaySound:         return "Snd Play";
    case kRespondSyncedPlaySound:   return "Snd Synched Play";
    case kRespondStopSound:         return "Snd Stop";
    case kRespondToggleSound:       return "Snd Toggle";
    case kRespondPlayRndSound:      return "Rnd Snd Play";
    case kRespondStopRndSound:      return "Rnd Snd Stop";
    case kRespondToggleRndSound:    return "Rnd Snd Toggle";
    case kRespondRewindAnim:        return "Anim Rewind";
    case kRespondRewindSound:       return "Snd Rewind";
    case kRespondFastForwardAnim:   return "Anim FFwd";
    }

    return nil;
}
const char *plResponderCmdAnim::GetInstanceName(IParamBlock2 *pb)
{
    static char name[256];

    const char *shortName = GetShortName(pb->GetInt(kAnimType));
    plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(kAnimComp);
    sprintf(name, "%s (%s)", shortName, node ? node->GetName() : "none");

    return name;
}

static bool IsSoundMsg(int type)
{
    if (type == kRespondPlaySound ||
        type == kRespondSyncedPlaySound ||
        type == kRespondStopSound ||
        type == kRespondToggleSound ||
        type == kRespondPlayRndSound ||
        type == kRespondStopRndSound ||
        type == kRespondToggleRndSound ||
        type == kRespondRewindSound)
        return true;
    return false;
}

IParamBlock2 *plResponderCmdAnim::CreatePB(int idx)
{
    int type = IndexToOldType(idx);

    // Create the paramblock and save it's type
    IParamBlock2 *pb = CreateParameterBlock2(&gResponderAnimBlock, nil);
    pb->SetValue(kAnimType, 0, type);

    return pb;
}

plComponentBase *plResponderCmdAnim::GetComponent(IParamBlock2 *pb)
{
    plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(kAnimComp);
    if (node)
        return node->ConvertToComponent();
    else
        return nil;
}

plMessage *plResponderCmdAnim::CreateMsg(plMaxNode* node, plErrorMsg *pErrMsg, IParamBlock2 *pb)
{
    if (IsSoundMsg(pb->GetInt(kAnimType)))
        return ICreateSndMsg(node, pErrMsg, pb);
    else
        return ICreateAnimMsg(node, pErrMsg, pb);
}

bool GetCompAndNode(IParamBlock2* pb, plMaxNode* node, plComponentBase*& comp, plMaxNode*& targNode)
{
    plMaxNode *compNode = (plMaxNode*)pb->GetReferenceTarget(kAnimComp);
    if (!compNode)
        return false;

    comp = compNode->ConvertToComponent();

    // KLUDGE: Anim group components don't need target nodes
    if (comp->ClassID() == ANIM_GROUP_COMP_CID)
        return true;

    if (pb->GetInt(kAnimObjectType) == kNodeResponder)
        targNode = node;
    else
        targNode = (plMaxNode*)pb->GetReferenceTarget(kAnimObject);

    if (!targNode)
        return false;

    if (!comp->IsTarget(targNode))
        return false;

    return true;
}

plMessage *plResponderCmdAnim::ICreateAnimMsg(plMaxNode* node, plErrorMsg *pErrMsg, IParamBlock2 *pb)
{
    plAnimComponentBase *comp = nil;
    plMaxNode *targNode = nil;
    if (!GetCompAndNode(pb, node, (plComponentBase*&)comp, targNode))
        throw "A valid animation component and node were not found";

    // Get the anim modifier keys for all nodes this comp is attached to
    plKey animKey = comp->GetModKey(targNode);
    if (!animKey)
        throw "Animation component didn't convert";

    plAnimCmdMsg *msg = TRACKED_NEW plAnimCmdMsg;
    msg->AddReceiver(animKey);

    const char *tempAnimName = comp->GetAnimName();
    msg->SetAnimName(tempAnimName);

    // Create and initialize a message for the command
    switch (pb->GetInt(kAnimType))
    {
    case kRespondPlayAnim:
        msg->SetCmd(plAnimCmdMsg::kContinue);
        break;
    case kRespondStopAnim:
        msg->SetCmd(plAnimCmdMsg::kStop);
        break;
    case kRespondToggleAnim:
        msg->SetCmd(plAnimCmdMsg::kToggleState);
        break;
    case kRespondSetForeAnim:
        msg->SetCmd(plAnimCmdMsg::kSetForewards);
        break;
    case kRespondSetBackAnim:
        msg->SetCmd(plAnimCmdMsg::kSetBackwards);
        break;
    case kRespondLoopAnimOn:
        {
            msg->SetCmd(plAnimCmdMsg::kSetLooping);
            // KLUDGE - We send the loop to play by name here, so anim grouped components
            // could have loops with different begin and end points.  However, apparently
            // that functionality was never implemented, whoops.  So, we'll take out the
            // stuff that actually tries to set the begin and end points for now, so that
            // anims with a loop set in advance will actually work with this. -Colin
//          msg->SetCmd(plAnimCmdMsg::kSetLoopBegin);
//          msg->SetCmd(plAnimCmdMsg::kSetLoopEnd);
            const char *loopName = pb->GetStr(kAnimLoop);
            msg->SetLoopName(loopName);
        }
        break;
    case kRespondLoopAnimOff:
        msg->SetCmd(plAnimCmdMsg::kUnSetLooping);
        break;

    case kRespondRewindAnim:
        msg->SetCmd(plAnimCmdMsg::kGoToBegin);
        break;
    case kRespondFastForwardAnim:
        msg->SetCmd(plAnimCmdMsg::kGoToEnd);
        break;
    }

    return msg;
}

plMessage* plResponderCmdAnim::ICreateSndMsg(plMaxNode* node, plErrorMsg *pErrMsg, IParamBlock2 *pb)
{
    plComponentBase *comp;
    plMaxNode *targNode;
    if (!GetCompAndNode(pb, node, comp, targNode))
        throw "A valid sound component and node were not found";

    int type = pb->GetInt(kAnimType);
    switch (type)
    {
        case kRespondPlaySound:
        case kRespondStopSound:
        case kRespondToggleSound:
        case kRespondRewindSound:
        case kRespondSyncedPlaySound:
        {
            if (!targNode->GetSceneObject())
                throw "Sound emitter didn't export";

            int soundIdx = plAudioComp::GetSoundModIdx(comp, targNode);

            // Changed 8.26.2001 mcn - The audioInterface should be the message receiver,
            // not the audible itself.
            const plAudioInterface *ai = targNode->GetSceneObject()->GetAudioInterface();
            plKey key = ai->GetKey();

            plSoundMsg* msg = TRACKED_NEW plSoundMsg;
            msg->AddReceiver(key);
            msg->fIndex = soundIdx;

            if (type == kRespondPlaySound)
                msg->SetCmd(plSoundMsg::kPlay);
            else if (type == kRespondStopSound)
                msg->SetCmd(plSoundMsg::kStop);
            else if (type == kRespondToggleSound)
                msg->SetCmd(plSoundMsg::kToggleState);
            else if (type == kRespondRewindSound)
            {
                msg->fTime = 0;
                msg->SetCmd(plSoundMsg::kGoToTime);
            }
            else if(type == kRespondSyncedPlaySound)
                msg->SetCmd(plSoundMsg::kSynchedPlay);

            if( plAudioComp::IsLocalOnly( comp ) )
                msg->SetCmd( plSoundMsg::kIsLocalOnly );

            return msg;
        }

        case kRespondPlayRndSound:
        case kRespondStopRndSound:
        case kRespondToggleRndSound:
        {
            plKey key = plAudioComp::GetRandomSoundKey(comp, targNode);
            if (key)
            {
                plAnimCmdMsg *msg = TRACKED_NEW plAnimCmdMsg;
                msg->AddReceiver(key);

                if (type == kRespondPlayRndSound)
                    msg->SetCmd(plAnimCmdMsg::kContinue);
                else if (type == kRespondStopRndSound)
                    msg->SetCmd(plAnimCmdMsg::kStop);
                else if (type == kRespondToggleRndSound)
                    msg->SetCmd(plAnimCmdMsg::kToggleState);

                return msg;
            }
        }
    }

    throw "Unknown sound command";
}

bool plResponderCmdAnim::IsWaitable(IParamBlock2 *pb)
{
    int type = pb->GetInt(kAnimType);
    if (type == kRespondPlayAnim ||
        type == kRespondToggleAnim ||
        type == kRespondStopAnim ||
        type == kRespondPlaySound ||
        type == kRespondSyncedPlaySound ||
        type == kRespondToggleSound)
        return true;

    return false;
}

void plResponderCmdAnim::GetWaitPoints(IParamBlock2 *pb, WaitPoints& waitPoints)
{
    int type = pb->GetInt(kAnimType);
    
    // Don't try and get points for the stop anim, it can only stop at a stop point
    if (type == kRespondStopAnim || IsSoundMsg(type))
        return;

    plAnimComponent *animComp = (plAnimComponent*)GetComponent(pb);
    const char *animName = animComp->GetAnimName();

    if (animComp)
    {
        plNotetrackAnim notetrackAnim(animComp, nil);
        plAnimInfo info = notetrackAnim.GetAnimInfo(animName);
        while (const char *marker = info.GetNextMarkerName())
            waitPoints.push_back(marker);
    }
}

void plResponderCmdAnim::CreateWait(plMaxNode* node, plErrorMsg* pErrMsg, IParamBlock2 *pb, ResponderWaitInfo& waitInfo)
{
    plAnimCmdMsg *animMsg = plAnimCmdMsg::ConvertNoRef(waitInfo.msg);
    if (animMsg)
        animMsg->SetCmd(plAnimCmdMsg::kAddCallbacks);

    plSoundMsg *soundMsg = plSoundMsg::ConvertNoRef(waitInfo.msg);
    if (soundMsg)
        soundMsg->SetCmd(plSoundMsg::kAddCallbacks);

    plEventCallbackMsg *eventMsg = TRACKED_NEW plEventCallbackMsg;
    eventMsg->AddReceiver(waitInfo.receiver);
    eventMsg->fRepeats = 0;
    eventMsg->fUser = waitInfo.callbackUser;

    if (waitInfo.point)
    {
        // FIXME COLIN - Error checking here?
        plAnimComponent *animComp = (plAnimComponent*)GetComponent(pb);
        const char *animName = animComp->GetAnimName();

        plNotetrackAnim notetrackAnim(animComp, nil);
        plAnimInfo info = notetrackAnim.GetAnimInfo(animName);

        eventMsg->fEvent = kTime;
        eventMsg->fEventTime = info.GetMarkerTime(waitInfo.point);
    }
    else
        eventMsg->fEvent = kStop;

    plMessageWithCallbacks *callbackMsg = plMessageWithCallbacks::ConvertNoRef(waitInfo.msg);
    callbackMsg->AddCallback(eventMsg);
    // AddCallback adds it's own ref, so remove ours (the default of 1)
    hsRefCnt_SafeUnRef(eventMsg);
}

#include "plAnimCompProc.h"
#include "plPickNode.h"
#include "plResponderGetComp.h"

class plResponderAnimProc : public plAnimCompProc
{
public:
    plResponderAnimProc();
    BOOL DlgProc(TimeValue t, IParamMap2 *pm, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

protected:
    virtual void IPickComponent(IParamBlock2* pb);
    virtual void IPickNode(IParamBlock2* pb, plComponentBase* comp);

    virtual void ILoadUser(HWND hWnd, IParamBlock2* pb);
    virtual bool IUserCommand(HWND hWnd, IParamBlock2* pb, int cmd, int resID);

    virtual void IUpdateNodeButton(HWND hWnd, IParamBlock2* pb);
};
static plResponderAnimProc gResponderAnimProc;

plResponderAnimProc::plResponderAnimProc()
{
    fCompButtonID   = IDC_ANIM_BUTTON;
    fCompParamID    = kAnimComp;
    fNodeButtonID   = IDC_OBJ_BUTTON;
    fNodeParamID    = kAnimObject;
}

BOOL plResponderAnimProc::DlgProc(TimeValue t, IParamMap2 *pm, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        {
            IParamBlock2 *pb = pm->GetParamBlock();

            int type = pb->GetInt(kAnimType);

            // Only show the loop control if this is a loop command
            int show = (type == kRespondLoopAnimOn) ? SW_SHOW : SW_HIDE;
            ShowWindow(GetDlgItem(hWnd, IDC_LOOP_COMBO), show);
            ShowWindow(GetDlgItem(hWnd, IDC_LOOP_TEXT), show);
            // Resize the dialog if we're not using the loop control
            if (type != kRespondLoopAnimOn)
            {
                RECT itemRect, clientRect;
                GetWindowRect(GetDlgItem(hWnd, IDC_LOOP_TEXT), &itemRect);
                GetWindowRect(hWnd, &clientRect);
                SetWindowPos(hWnd, NULL, 0, 0, clientRect.right-clientRect.left,
                    itemRect.top-clientRect.top, SWP_NOMOVE | SWP_NOZORDER);
            }

            if (IsSoundMsg(type))
                SetDlgItemText(hWnd, IDC_COMP_TEXT, "Sound Component");
        }
        break;
    }

    return plAnimCompProc::DlgProc(t, pm, hWnd, msg, wParam, lParam);
}

bool plResponderAnimProc::IUserCommand(HWND hWnd, IParamBlock2* pb, int cmd, int resID)
{
    if (cmd == CBN_SELCHANGE && resID == IDC_LOOP_COMBO)
    {
        HWND hCombo = GetDlgItem(hWnd, IDC_LOOP_COMBO);
        int sel = ComboBox_GetCurSel(hCombo);

        // If this is an actual loop (not the entire animation) get its name and save it
        if (sel != CB_ERR)
        {
            if (ComboBox_GetItemData(hCombo, sel) == 1)
            {
                char buf[256];
                ComboBox_GetText(hCombo, buf, sizeof(buf));
                pb->SetValue(kAnimLoop, 0, buf);
            }
            else
                pb->SetValue(kAnimLoop, 0, "");
        }

        return true;
    }

    return false;
}

void plResponderAnimProc::IPickComponent(IParamBlock2* pb)
{
    std::vector<Class_ID> cids;

    int type = pb->GetInt(kAnimType);
    if (type == kRespondPlaySound ||
        type == kRespondStopSound ||
        type == kRespondToggleSound ||
        type == kRespondRewindSound || 
        type == kRespondSyncedPlaySound)
    {
        cids.push_back(SOUND_3D_COMPONENT_ID);
        cids.push_back(BGND_MUSIC_COMPONENT_ID);
        cids.push_back(GUI_SOUND_COMPONENT_ID);
    }
    else if (type == kRespondPlayRndSound ||
            type == kRespondStopRndSound ||
            type == kRespondToggleRndSound)
    {
        cids.push_back(RANDOM_SOUND_COMPONENT_ID);
    }
    else
    {
        cids.push_back(ANIM_COMP_CID);
        cids.push_back(ANIM_GROUP_COMP_CID);
    }

    plPick::NodeRefKludge(pb, kAnimComp, &cids, true, false);
}

#include "plPickNodeBase.h"

static const char* kResponderNodeName = "(Responder Node)";

class plPickRespNode : public plPickCompNode
{
protected:
    int fTypeID;

    void IAddUserType(HWND hList)
    {
        int idx = ListBox_AddString(hList, kResponderNodeName);

        int type = fPB->GetInt(fTypeID);
        if (type == kNodeResponder)
            ListBox_SetCurSel(hList, idx);
    }

    void ISetUserType(plMaxNode* node, const char* userType)
    {
        if (userType && !strcmp(userType, kResponderNodeName))
        {
            ISetNodeValue(nil);
            fPB->SetValue(fTypeID, 0, kNodeResponder);
        }
        else
            fPB->SetValue(fTypeID, 0, kNodePB);
    }

public:
    plPickRespNode(IParamBlock2* pb, int nodeParamID, int typeID, plComponentBase* comp) :
      plPickCompNode(pb, nodeParamID, comp), fTypeID(typeID)
    {
    }
};

void plResponderAnimProc::IPickNode(IParamBlock2* pb, plComponentBase* comp)
{
    plPickRespNode pick(pb, kAnimObject, kAnimObjectType, comp);
    pick.DoPick();
}

#include "plNotetrackAnim.h"

void plResponderAnimProc::ILoadUser(HWND hWnd, IParamBlock2 *pb)
{
    // Premptive strike.  If this isn't a loop, don't bother!
    int type = pb->GetInt(kAnimType);
    if (type != kRespondLoopAnimOn)
        return;

    HWND hLoop = GetDlgItem(hWnd, IDC_LOOP_COMBO);

    const char *savedName = pb->GetStr(kAnimLoop);
    if (!savedName)
        savedName = "";

    // Reset the combo and add the default selection
    ComboBox_ResetContent(hLoop);
    int sel = ComboBox_AddString(hLoop, ENTIRE_ANIMATION_NAME);
    ComboBox_SetCurSel(hLoop, sel);

    // FIXME
    plComponentBase *comp = plResponderCmdAnim::Instance().GetComponent(pb);
    if (comp && comp->ClassID() == ANIM_COMP_CID)
    {
        const char *animName = ((plAnimComponent*)comp)->GetAnimName();

        // Get the shared animations for all the nodes this component is applied to
        plNotetrackAnim anim(comp, nil);
        plAnimInfo info = anim.GetAnimInfo(animName);
        // Get all the loops in this animation
        while (const char *loopName = info.GetNextLoopName())
        {
            int idx = ComboBox_AddString(hLoop, loopName);
            ComboBox_SetItemData(hLoop, idx, 1);

            if (!strcmp(loopName, savedName))
                ComboBox_SetCurSel(hLoop, idx);
        }

        EnableWindow(hLoop, TRUE);
    }
    else
    {
        EnableWindow(hLoop, FALSE);
    }
}

void plResponderAnimProc::IUpdateNodeButton(HWND hWnd, IParamBlock2* pb)
{
    if (pb->GetInt(kAnimObjectType) == kNodeResponder)
    {
        HWND hButton = GetDlgItem(hWnd, IDC_OBJ_BUTTON);
        SetWindowText(hButton, kResponderNodeName);
    }
    else
        plAnimCompProc::IUpdateNodeButton(hWnd, pb);
}