CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxComponent/plResponderComponent.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 "plResponderComponentPriv.h"
#include "resource.h"
#include "plComponent.h"
#include "plComponentReg.h"

#include "../pnSceneObject/plSceneObject.h"
#include "../pnKeyedObject/hsKeyedObject.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnNetCommon/plSDLTypes.h"

#include "../plModifier/plResponderModifier.h"
#include "../plModifier/plLogicModifier.h"
#include "../plModifier/plAxisAnimModifier.h"
#include "../pfConditional/plActivatorConditionalObject.h"
#include "../pfConditional/plORConditionalObject.h"

#include "../pnMessage/plObjRefMsg.h"
#include "../pnMessage/plNotifyMsg.h"

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

#include "plPickNode.h"

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

#include "plResponderLink.h"
#include "plResponderAnim.h"
#include "plResponderMtl.h"
#include "plResponderWait.h"

#include "../MaxMain/plMaxAccelerators.h"

IParamBlock2 *CreateWaitBlk();

int ResponderGetActivatorCount(plComponentBase *comp)
{
	if (comp->ClassID() == RESPONDER_CID)
		return comp->GetParamBlockByID(plComponentBase::kBlkComp)->Count(kResponderActivators);

	return -1;
}

plComponentBase *ResponderGetActivator(plComponentBase *comp, int idx)
{
	if (comp->ClassID() == RESPONDER_CID)
	{
		IParamBlock2 *pb = comp->GetParamBlockByID(plComponentBase::kBlkComp);
		plMaxNode *activatorNode = (plMaxNode*)pb->GetINode(kResponderActivators, 0, idx);
		return activatorNode->ConvertToComponent();
	}

	return nil;
}

plKey Responder::GetKey(plComponentBase *comp, plMaxNodeBase *node)
{
	if (comp->ClassID() != RESPONDER_CID)
		return nil;

	plResponderComponent *responder = (plResponderComponent*)comp;
	if (responder->fModKeys.find((plMaxNode*)node) != responder->fModKeys.end())
		return responder->fModKeys[(plMaxNode*)node];

	return nil;	
}

CLASS_DESC(plResponderComponent, gResponderDesc, "Responder", "Responder", COMP_TYPE_LOGIC, RESPONDER_CID)

class plResponderProc;
extern plResponderProc gResponderComponentProc;

// When one of our parameters that is a ref changes, send out the component ref
// changed message.  Normally, messages from component refs are ignored since
// they pass along all the messages of the ref, which generates a lot of false
// converts.
class plResponderAccessor : public PBAccessor
{
public:
	void Set(PB2Value& v, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t)
	{
		if (id == kResponderActivators || id == kResponderState)
		{
			plResponderComponent *comp = (plResponderComponent*)owner;
			comp->NotifyDependents(FOREVER, PART_ALL, REFMSG_USER_COMP_REF_CHANGED);
		}
	}
};
static plResponderAccessor gResponderAccessor;

ParamBlockDesc2 gResponderBlock
(
	plComponent::kBlkComp, _T("responderComp"), 0, &gResponderDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_RESPOND, IDS_COMP_RESPOND, 0, 0, &gResponderComponentProc,

	kResponderState,	_T("state"),		TYPE_REFTARG_TAB, 0,		0, 0,
		p_accessor,		&gResponderAccessor,
		end,
	kResponderStateName, _T("stateName"),	TYPE_STRING_TAB, 0,			0, 0,
		end,

	kResponderActivators,	_T("activators"),	TYPE_INODE_TAB, 0,		0, 0,
		p_ui,			TYPE_NODELISTBOX, IDC_LIST_TARGS, 0, 0, IDC_DEL_TARGS,
		p_accessor,		&gResponderAccessor,
		end,

	kResponderStateDef,	_T("defState"),		TYPE_INT,					0, 0,
		end,

	kResponderEnabled, _T("enabled"),	TYPE_BOOL,					0, 0,
		p_default,	TRUE,
		p_ui,		TYPE_SINGLECHEKBOX, IDC_ENABLED,
		end,

	kResponderTrigger, _T("trigger"),	TYPE_BOOL,					0, 0,
		p_default,	TRUE,
		p_ui,		TYPE_SINGLECHEKBOX, IDC_CHECK_TRIGGER,
		end,

	kResponderUnTrigger, _T("unTrigger"),	TYPE_BOOL,				0, 0,
		p_default,	FALSE,
		p_ui,		TYPE_SINGLECHEKBOX, IDC_CHECK_UNTRIGGER,
		end,

	kResponderLocalDetect, _T("localDetect"),	TYPE_BOOL,			0, 0,
		p_default,	FALSE,
		p_ui,		TYPE_SINGLECHEKBOX, IDC_DETECT_LOCAL_CHECK,
		end,

	kResponderSkipFFSound, _T("skipFFSound"),	TYPE_BOOL,					0, 0,
		p_default,	FALSE,
		p_ui,		TYPE_SINGLECHEKBOX, IDC_CHECK_SKIPFFSOUND,
		end,

	end
);

ParamBlockDesc2 gStateBlock
(
	kResponderStateBlk, _T("responderState"), 0, &gResponderDesc, 0,

	kStateCmdParams, _T("cmdParam"),	TYPE_REFTARG_TAB, 0,		0, 0,
		end,

	kStateCmdWait,	_T("cmdWait"),		TYPE_REFTARG_TAB, 0,		0, 0,
		end,

	kStateCmdSwitch, _T("cmdSwitch"),	TYPE_INT,					0, 0,
		end,

	kStateCmdEnabled, _T("enabled"),	TYPE_BOOL_TAB, 0,			0, 0,
		p_default,	TRUE,
		end,

	end
);

std::vector<plResponderCmd*> gResponderCmds;

plResponderCmd *plResponderCmd::Find(IParamBlock2 *pb)
{
	if (!pb)
		return nil;

	ParamBlockDesc2 *pbDesc = pb->GetDesc();

	for (int i = 0; i < gResponderCmds.size(); i++)
	{
		if (gResponderCmds[i]->GetDesc() == pbDesc)
			return gResponderCmds[i];
	}

	return nil;
}

IParamBlock2* plResponderCmd::CreatePB(int idx)
{
	hsAssert(NumTypes() == 1, "Can't auto-create the pb for a cmd with multiple types");
	IParamBlock2 *pb = CreateParameterBlock2(GetDesc(), nil);
	return pb;
}

void DummyCodeIncludeFuncResponder()
{
	gResponderCmds.push_back(&(plResponderCmdVisibility::Instance()));
	gResponderCmds.push_back(&(plResponderCmdLink::Instance()));
	gResponderCmds.push_back(&(plResponderCmdEnable::Instance()));
	gResponderCmds.push_back(&(plResponderCmdXRegion::Instance()));
	gResponderCmds.push_back(&(plResponderCmdOneShot::Instance()));
	gResponderCmds.push_back(&(plResponderCmdNotify::Instance()));
	gResponderCmds.push_back(&(plResponderCmdDetectorEnable::Instance()));
	gResponderCmds.push_back(&(plResponderCmdCamTransition::Instance()));
	gResponderCmds.push_back(&(plResponderCmdCamForce::Instance()));
	gResponderCmds.push_back(&(plResponderCmdAnim::Instance()));
	gResponderCmds.push_back(&(plResponderCmdMtl::Instance()));
	gResponderCmds.push_back(&(plResponderCmdDelay::Instance()));
	gResponderCmds.push_back(&(plResponderCmdFootSurface::Instance()));
	gResponderCmds.push_back(&(plResponderCmdMultistage::Instance()));
	gResponderCmds.push_back(&(plResponderCmdPhysEnable::Instance()));
	gResponderCmds.push_back(&(plResponderCmdSubWorld::Instance()));

	for (int i = 0; i < gResponderCmds.size(); i++)
		gResponderCmds[i]->GetDesc()->SetClassDesc(&gResponderDesc);

	ResponderWait::SetDesc(&gResponderDesc);
}

plResponderComponent::plResponderComponent()
{
	fClassDesc = &gResponderDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plResponderComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
	int numStates = fCompPB->Count(kResponderState);
	for (int i = 0; i < numStates; i++)
	{
		IParamBlock2 *statePB = (IParamBlock2*)fCompPB->GetReferenceTarget(kResponderState, 0, i);

		for (int j = 0; j < statePB->Count(kStateCmdParams); j++)
		{
			IParamBlock2 *cmdPB = (IParamBlock2*)statePB->GetReferenceTarget(kStateCmdParams, 0, j);
			plResponderCmd *cmd = plResponderCmd::Find(cmdPB);
			cmd->SetupProperties(node, pErrMsg, cmdPB);
		}
	}

	return true;
}

hsBool plResponderComponent::PreConvert(plMaxNode *node,plErrorMsg *pErrMsg)
{
	plSceneObject* rObj = node->GetSceneObject();
	plLocation loc = node->GetLocation();

	// Create and register the RESPONDER's logic component
	plResponderModifier *responder = TRACKED_NEW plResponderModifier;
	plKey responderKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), responder, loc);
	hsgResMgr::ResMgr()->AddViaNotify(responderKey, TRACKED_NEW plObjRefMsg(rObj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);

	// Tell all the activators to notify us
	for (int i = 0; i < fCompPB->Count(kResponderActivators); i++)
	{
		plMaxNode *activatorNode = (plMaxNode*)fCompPB->GetINode(kResponderActivators, 0, i);
		plComponentBase *comp = activatorNode ? activatorNode->ConvertToComponent() : nil;
		if (comp)
		{
			if (fCompPB->GetInt(kResponderLocalDetect))
				comp->AddReceiverKey(responderKey, node);
			else
				comp->AddReceiverKey(responderKey);
		}
	}

	fModKeys[node] = responderKey;

	return true;
}

plResponderModifier* plResponderComponent::IGetResponderMod(plMaxNode* node)
{
	plKey responderKey = fModKeys[node];
	return plResponderModifier::ConvertNoRef(responderKey->GetObjectPtr());
}

hsBool plResponderComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
	IFixOldPB();

	// Create the commands for each state
	int numStates = fCompPB->Count(kResponderState);

	plResponderModifier *responder = IGetResponderMod(node);
	responder->fStates.SetCount(numStates);

	for (int i = 0; i < numStates; i++)
	{
		CmdIdxs cmdIdxs;

		IConvertCmds(node, pErrMsg, i, cmdIdxs);

		int numCallbacks = 0;
		ISetupDefaultWait(node, pErrMsg, i, cmdIdxs, numCallbacks);
		IConvertCmdWaits(node, pErrMsg, i, cmdIdxs, numCallbacks);

		IParamBlock2 *statePB = (IParamBlock2*)fCompPB->GetReferenceTarget(kResponderState, 0, i);
		responder->fStates[i].fNumCallbacks = numCallbacks;
		responder->fStates[i].fSwitchToState = statePB->GetInt(kStateCmdSwitch);
	}

	// Set the initial state
	responder->fCurState = fCompPB->GetInt(kResponderStateDef);
	responder->fEnabled = fCompPB->GetInt(kResponderEnabled) != 0;

	if (fCompPB->GetInt(kResponderTrigger))
		responder->fFlags |= plResponderModifier::kDetectTrigger;
	if (fCompPB->GetInt(kResponderUnTrigger))
		responder->fFlags |= plResponderModifier::kDetectUnTrigger;
	if (fCompPB->GetInt(kResponderSkipFFSound))
		responder->fFlags |= plResponderModifier::kSkipFFSound;

	// Unless it's been overridden somewhere else, don't save our state on the server
	if (!node->GetOverrideHighLevelSDL())
		responder->AddToSDLExcludeList(kSDLResponder);

	return true;
}

hsBool plResponderComponent::DeInit(plMaxNode *node, plErrorMsg *pErrMsg)
{
	fModKeys.clear();
	return true;
}

void plResponderComponent::IConvertCmds(plMaxNode* node, plErrorMsg* pErrMsg, int state, CmdIdxs& cmdIdxs)
{
	IParamBlock2 *statePB = (IParamBlock2*)fCompPB->GetReferenceTarget(kResponderState, 0, state);
	plResponderModifier *responder = IGetResponderMod(node);

	// Add the messages to the logic modifier
	for (int i = 0; i < statePB->Count(kStateCmdParams); i++)
	{
		plMessage *msg = nil;

		BOOL enabled = statePB->GetInt(kStateCmdEnabled, 0, i);
		if (!enabled)
			continue;

		IParamBlock2 *cmdPB = (IParamBlock2*)statePB->GetReferenceTarget(kStateCmdParams, 0, i);

		try
		{
			plResponderCmd *cmd = plResponderCmd::Find(cmdPB);
			if (cmd)
				msg = cmd->CreateMsg(node, pErrMsg, cmdPB);
		}
		catch (char *reason)
		{
			char buf[512];

			char stateName[128];
			const char *curStateName = fCompPB->GetStr(kResponderStateName, 0, state);
			if (curStateName && *curStateName != '\0')
				strcpy(stateName, fCompPB->GetStr(kResponderStateName, 0, state));
			else
				sprintf(stateName, "State %d", state+1);

			sprintf(buf,
				"A responder command failed to export.\n\nResponder:\t%s\nState:\t\t%s\nCommand:\t%d\n\nReason: %s",
				GetINode()->GetName(), stateName, i+1, reason);

			pErrMsg->Set(true, "Responder Warning", buf).Show();
			pErrMsg->Set(false);
		}

		if (msg)
		{
			msg->SetSender(responder->GetKey());
			responder->AddCommand(msg, state);
			int idx = responder->fStates[state].fCmds.Count()-1;
			cmdIdxs[i] = idx;
		}
	}
}

static IParamBlock2 *GetWaitBlk(IParamBlock2 *state, int idx)
{
	return (IParamBlock2*)state->GetReferenceTarget(kStateCmdWait, 0, idx);
}

void plResponderComponent::ISetupDefaultWait(plMaxNode* node, plErrorMsg* pErrMsg,
											 int state, CmdIdxs& cmdIdxs, int &numCallbacks)
{
	IParamBlock2 *statePB = (IParamBlock2*)fCompPB->GetReferenceTarget(kResponderState, 0, state);
	plResponderModifier *responder = IGetResponderMod(node);
	hsTArray<plResponderModifier::plResponderCmd>& cmds = responder->fStates[state].fCmds;

	int numCmds = cmds.Count();
	for (int i = 0; i < numCmds; i++)
	{
		IParamBlock2 *waitPB = GetWaitBlk(statePB, i);
		ResponderWait::FixupWaitBlock(waitPB);

		// If we're supposed to wait for this command, and it converted, create a callback
		if (ResponderWait::GetWaitOnMe(waitPB) && cmdIdxs.find(i) != cmdIdxs.end())
		{
			int convertedIdx = cmdIdxs[i];

			ResponderWaitInfo waitInfo;
			waitInfo.responderName = GetINode()->GetName();
			waitInfo.receiver = responder->GetKey();
			waitInfo.callbackUser = numCallbacks++;
			waitInfo.msg = cmds[convertedIdx].fMsg;
			waitInfo.point = nil;

			IParamBlock2 *pb = (IParamBlock2*)statePB->GetReferenceTarget(kStateCmdParams, 0, i);
			plResponderCmd *cmd = plResponderCmd::Find(pb);

			cmd->CreateWait(node, pErrMsg, pb, waitInfo);
		}
	}
}

void plResponderComponent::IConvertCmdWaits(plMaxNode* node, plErrorMsg* pErrMsg,
											int state, CmdIdxs& cmdIdxs, int &numCallbacks)
{
	IParamBlock2 *statePB = (IParamBlock2*)fCompPB->GetReferenceTarget(kResponderState, 0, state);
	plResponderModifier *responder = IGetResponderMod(node);
	hsTArray<plResponderModifier::plResponderCmd>& cmds = responder->fStates[state].fCmds;

	int numWaits = statePB->Count(kStateCmdWait);
	for (int i = 0; i < numWaits; i++)
	{
		IParamBlock2 *waitPB = GetWaitBlk(statePB, i);

		int wait = ResponderWait::GetWaitingOn(waitPB);

		// If the waiter and waitee both converted, create the callback
		if (cmdIdxs.find(wait) != cmdIdxs.end() && cmdIdxs.find(i) != cmdIdxs.end())
		{
			int convertedIdx = cmdIdxs[wait];

			ResponderWaitInfo waitInfo;
			waitInfo.responderName = GetINode()->GetName();
			waitInfo.receiver = responder->GetKey();
			waitInfo.callbackUser = numCallbacks++;
			waitInfo.msg = cmds[convertedIdx].fMsg;
			waitInfo.point = ResponderWait::GetWaitPoint(waitPB);

			responder->AddCallback(state, convertedIdx, waitInfo.callbackUser);
			cmds[cmdIdxs[i]].fWaitOn = waitInfo.callbackUser;

			IParamBlock2 *pb = (IParamBlock2*)statePB->GetReferenceTarget(kStateCmdParams, 0, wait);
			plResponderCmd *cmd = plResponderCmd::Find(pb);

			cmd->CreateWait(node, pErrMsg, pb, waitInfo);
		}
	}
}

void plResponderComponent::IFixOldPB()
{
	if (fCompPB)
	{
		if (fCompPB->Count(kResponderState) == 0)
		{
			IParamBlock2 *pb = CreateParameterBlock2(&gStateBlock, nil);
			int idx = fCompPB->Append(kResponderState, 1, (ReferenceTarget**)&pb);
			pb->SetValue(kStateCmdSwitch, 0, idx);
		}
		if (fCompPB->Count(kResponderStateName) == 0)
		{
			char *name = "";
			fCompPB->Append(kResponderStateName, 1, &name);
		}

		// Make sure there is an enabled value for each command in the state
		for (int i = 0; i < fCompPB->Count(kResponderState); i++)
		{
			IParamBlock2* pb = (IParamBlock2*)fCompPB->GetReferenceTarget(kResponderState, 0, i);
			if (pb->Count(kStateCmdEnabled) != pb->Count(kStateCmdParams))
				pb->SetCount(kStateCmdEnabled, pb->Count(kStateCmdParams));
		}
	}
}

////////////////////////////////////////////////////////////////////////////////

#define CUSTOM_DRAW

enum
{
	kStateName,
	kStateAdd,
	kStateRemove,
	kStateDefault,
	kStateCopy,
};

class plResponderProc : public ParamMap2UserDlgProc
{
protected:
	HWND fhDlg;
	IParamBlock2 *fPB;
	IParamBlock2 *fStatePB;
	int fCurState;
	
	plResponderComponent *fComp;

	IParamMap2 *fCmdMap;
	IParamMap2 *fWaitMap;
	
	int fCmdIdx;

	typedef std::map<int, const char*> NameID;
	NameID fNames;

	HMENU fhMenu;
	typedef std::pair<plResponderCmd*, int> CmdID;
	typedef std::map<int, CmdID> MenuCmd;
	MenuCmd fMenuCmds;

	HWND fhList;

	bool fIgnoreNextDrop;

public:
	plResponderProc();

	BOOL DlgProc(TimeValue t, IParamMap2 *pm, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
	void DeleteThis() { IRemoveCmdRollups(); }

protected:
	void ICreateMenu();
	void IAddMenuItem(HMENU hMenu, int id);

	void ICmdRightClick(HWND hCmdList);

	// Add and remove command rollups
	void ICreateCmdRollups();
	void IRemoveCmdRollups();
	IParamMap2 *ICreateMap(IParamBlock2 *pb);	// Helper

	const char* GetCommandName(int cmdIdx);
	void LoadList();

	BOOL DragListProc(HWND hWnd, DRAGLISTINFO *info);

#ifdef CUSTOM_DRAW
	void IDrawComboItem(DRAWITEMSTRUCT *dis);
#endif

	void LoadState();
	
	void AddCommand();
	void RemoveCurCommand();
	void MoveCommand(int oldIdx, int newIdx);

	// Takes a freshly created state PB and adds it as a new state, then returns its index
	int AddState(IParamBlock2 *pb);
};
static plResponderProc gResponderComponentProc;

void plResponderProc::IAddMenuItem(HMENU hMenu, int id)
{
	AppendMenu(hMenu, MF_STRING, id+1, fNames[id]);
}

#include "hsSTLSortUtils.h"

void plResponderProc::ICreateMenu()
{
	fhMenu = CreatePopupMenu();

	std::map<const char *, HMENU, stringSorter> menus;
	int cmdID = 0;

	for (int i = 0; i < gResponderCmds.size(); i++)
	{
		plResponderCmd *cmd = gResponderCmds[i];
		for (int j = 0; j < cmd->NumTypes(); j++)
		{
			HMENU hParent = fhMenu;

			const char *category = cmd->GetCategory(j);
			if (category)
			{
				// Menu for this category hasn't been created yet, make one
				if (menus.find(category) == menus.end())
				{
					hParent = CreatePopupMenu();
					menus[category] = hParent;
					InsertMenu(fhMenu, 0, MF_BYPOSITION | MF_POPUP, (UINT)hParent, category);
				}
				else
					hParent = menus[category];
			}

			const char *name = cmd->GetName(j);
			
			cmdID++;
			fMenuCmds[cmdID] = CmdID(cmd, j);
			AppendMenu(hParent, MF_STRING, cmdID, name);
		}
	}
}

plResponderProc::plResponderProc() : fCmdMap(nil), fCmdIdx(-1), fCurState(0), fhMenu(nil), fIgnoreNextDrop(false)
{
}

const char* plResponderProc::GetCommandName(int cmdIdx)
{
	static char buf[256];

	if (fStatePB->Count(kStateCmdParams) > cmdIdx)
	{
		buf[0] = '\0';

		BOOL enabled = fStatePB->GetInt(kStateCmdEnabled, 0, cmdIdx);
		if (!enabled)
			strcat(buf, "[D]");

		IParamBlock2 *cmdPB = (IParamBlock2*)fStatePB->GetReferenceTarget(kStateCmdParams, 0, cmdIdx);
		plResponderCmd *cmd = plResponderCmd::Find(cmdPB);

		IParamBlock2 *waitPB = (IParamBlock2*)fStatePB->GetReferenceTarget(kStateCmdWait, 0, cmdIdx);
		int waitingOn = ResponderWait::GetWaitingOn(waitPB);
		if (waitingOn != -1)
		{
			char num[10];
			sprintf(num, "(%d)", waitingOn+1);
			strcat(buf, num);
		}

		strcat(buf, cmd->GetInstanceName(cmdPB));

		return buf;
	}

	hsAssert(0, "Bad index to GetCommandName");
	return nil;
}

void plResponderProc::LoadList()
{
	ListBox_ResetContent(fhList);

	for (int i = 0; i < fStatePB->Count(kStateCmdParams); i++)
	{
		const char* name = GetCommandName(i);
		ListBox_AddString(fhList, name);
	}

	ListBox_SetCurSel(fhList, -1);
}

void plResponderProc::AddCommand()
{
	RECT rect;
	GetWindowRect(GetDlgItem(fhDlg, IDC_ADD_CMD), &rect);

	// Create the popup menu and get the option the user selects
	SetForegroundWindow(fhDlg);
	int type = TrackPopupMenu(fhMenu, TPM_RIGHTALIGN | TPM_NONOTIFY | TPM_RETURNCMD, rect.left, rect.top, 0, fhDlg, NULL);
	PostMessage(fhDlg, WM_USER, 0, 0);

	if (type == 0)
		return;

	CmdID& cmdID = fMenuCmds[type];
	plResponderCmd *cmd = cmdID.first;
	int cmdIdx = cmdID.second;

	IParamBlock2 *cmdPB = cmd->CreatePB(cmdIdx);
	fStatePB->Append(kStateCmdParams, 1, (ReferenceTarget**)&cmdPB);

	IParamBlock2 *waitPB = ResponderWait::CreatePB();
	fStatePB->Append(kStateCmdWait, 1, (ReferenceTarget**)&waitPB);

	BOOL enabled = TRUE;
	fStatePB->Append(kStateCmdEnabled, 1, &enabled);

	const char* name = GetCommandName(fStatePB->Count(kStateCmdParams)-1);
	int idx = ListBox_AddString(fhList, name);
	ListBox_SetCurSel(fhList, idx);

	ICreateCmdRollups();
}

void plResponderProc::RemoveCurCommand()
{
	int idx = ListBox_GetCurSel(fhList);
	if (idx == LB_ERR)
		return;

	// Destroy the current rollup, since it's this guy
	IRemoveCmdRollups();

	// Delete all traces of this command
	fStatePB->Delete(kStateCmdParams, idx, 1);
	fStatePB->Delete(kStateCmdWait, idx, 1);
	fStatePB->Delete(kStateCmdEnabled, idx, 1);
	ListBox_DeleteString(fhList, idx);

	// Patch the wait commands
	ResponderWait::CmdRemoved(fStatePB, idx);
	
	fCmdIdx = -1;
}

void plResponderProc::IRemoveCmdRollups()
{
	if (fCmdMap)
	{
		DestroyCPParamMap2(fCmdMap);
		fCmdMap = nil;
	}
	if (fWaitMap)
	{
		DestroyCPParamMap2(fWaitMap);
		fWaitMap = nil;
	}
}

IParamMap2 *plResponderProc::ICreateMap(IParamBlock2 *pb)
{
	ParamBlockDesc2 *pd = pb->GetDesc();

	// Don't show anything if there isn't a UI
	if (pd->Count() < 1)
	{
		pb->ReleaseDesc();
		return nil;
	}

	// Create the rollout
	IParamMap2 *map = CreateCPParamMap2(0,
										pb,
										GetCOREInterface(),
										hInstance,
										MAKEINTRESOURCE(pd->dlg_template),
										GetString(pd->title),
										pd->flags,
										pd->dlgProc,
										NULL,
										ROLLUP_CAT_STANDARD);

	// Save the rollout in the paramblock
	pb->SetMap(map);
	pb->ReleaseDesc();

	return map;
}

void plResponderProc::ICreateCmdRollups()
{
	// Get the index of the current command
	HWND hCmds = GetDlgItem(fhDlg, IDC_CMD_LIST);
	int cmdIdx = ListBox_GetCurSel(hCmds);

	if (cmdIdx != LB_ERR && cmdIdx != fCmdIdx)
	{
		fCmdIdx = cmdIdx;
		fIgnoreNextDrop = true;

		// Save the current scroll position and reset it at the end, so the panels
		// won't always jerk back up to the top
		IRollupWindow *rollup = GetCOREInterface()->GetCommandPanelRollup();
		int scrollPos = rollup->GetScrollPos();

		// Destroy the last command's rollups
		IRemoveCmdRollups();

		// Create the rollup for the current command
		IParamBlock2 *pb = (IParamBlock2*)fStatePB->GetReferenceTarget(kStateCmdParams, 0, fCmdIdx);
		fCmdMap = ICreateMap(pb);

		ResponderWait::InitDlg(fStatePB, fCmdIdx, GetDlgItem(fhDlg, IDC_CMD_LIST));
		pb = (IParamBlock2*)fStatePB->GetReferenceTarget(kStateCmdWait, 0, fCmdIdx);
		fWaitMap = ICreateMap(pb);

		rollup->SetScrollPos(scrollPos);
	}
}

BOOL plResponderProc::DragListProc(HWND hWnd, DRAGLISTINFO *info)
{
	static int oldIdx = -1;

	int curIdx = LBItemFromPt(info->hWnd, info->ptCursor, TRUE);

	switch (info->uNotification)
	{
		// Allow the drag
		case DL_BEGINDRAG:
			// When you click on an item in the listbox, the rollups are changed and Max can
			// shift the position of dialog you were just clicking in.  Since this happens
			// before you let go of the mouse button, the listbox thinks you are dragging.
			// To get around it, we don't allow a selection change and a drag in the same click.
			if (fIgnoreNextDrop)
			{
				SetWindowLong(hWnd, DWL_MSGRESULT, FALSE);
			}
			else
			{
				oldIdx = curIdx;
				SetWindowLong(hWnd, DWL_MSGRESULT, TRUE);
			}
			return TRUE;

		case DL_DRAGGING:
			{
				if (curIdx < oldIdx)
					DrawInsert(hWnd, info->hWnd, curIdx);
				else if (curIdx > oldIdx && ListBox_GetCount(info->hWnd) > curIdx+1)
					DrawInsert(hWnd, info->hWnd, curIdx+1);
				else
					DrawInsert(hWnd, info->hWnd, -1);
			}
			return TRUE;

		case DL_CANCELDRAG:
			// Clear drag arrow
			DrawInsert(hWnd, info->hWnd, -1);
			return TRUE;

		case DL_DROPPED:
		{
			if (fIgnoreNextDrop)
			{
				fIgnoreNextDrop = false;
				return TRUE;
			}

			// Clear drag arrow
			DrawInsert(hWnd, info->hWnd, -1);

			if (curIdx != -1 && oldIdx != -1 && curIdx != oldIdx)
			{
				// Make sure this won't mess up any wait commands, or at least
				// that the user approves if it does.
				if (!ResponderWait::ValidateCmdMove(fStatePB, oldIdx, curIdx))
					return TRUE;

				MoveCommand(oldIdx, curIdx);
			}

			return TRUE;
		}
	}

	return FALSE;
}

#ifdef CUSTOM_DRAW
void plResponderProc::IDrawComboItem(DRAWITEMSTRUCT *dis)
{
	if (dis->itemID == -1)			// empty item
		return; 

	// The colors depend on whether the item is selected. 
	COLORREF clrForeground = SetTextColor(dis->hDC, 
		GetSysColor(dis->itemState & ODS_SELECTED ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT)); 

	COLORREF clrBackground = SetBkColor(dis->hDC, 
		GetSysColor(dis->itemState & ODS_SELECTED ? COLOR_HIGHLIGHT : COLOR_WINDOW)); 

	// Calculate the vertical and horizontal position.
	TEXTMETRIC tm;
	GetTextMetrics(dis->hDC, &tm);
	int y = (dis->rcItem.bottom + dis->rcItem.top - tm.tmHeight) / 2;
	int x = LOWORD(GetDialogBaseUnits()) / 4;

	// If this is a command, not a state, make it bold
	HFONT oldFont = nil;
	if (dis->itemData != kStateName)
	{
		LOGFONT lf;
		memset(&lf, 0, sizeof(lf));
		lf.lfHeight = tm.tmHeight;
		lf.lfWeight = FW_BOLD;
		GetTextFace(dis->hDC, LF_FACESIZE, lf.lfFaceName);
		HFONT boldFont = CreateFontIndirect(&lf);
		oldFont = SelectFont(dis->hDC, boldFont);
	}

	// Get and display the text for the list item.
	char buf[256];
	ComboBox_GetLBText(dis->hwndItem, dis->itemID, buf);
	if (fPB->GetInt(kResponderStateDef) == dis->itemID)
	{
		char buf2[256];
		sprintf(buf2, "* %s", buf);
		strcpy(buf, buf2);
	}

	ExtTextOut(dis->hDC, x, y, ETO_CLIPPED | ETO_OPAQUE, &dis->rcItem, buf, strlen(buf), NULL); 

	// Restore the previous colors. 
	SetTextColor(dis->hDC, clrForeground); 
	SetBkColor(dis->hDC, clrBackground); 

	if (oldFont)
		DeleteFont(SelectFont(dis->hDC, oldFont));

	// If the item has the focus, draw focus rectangle. 
	if (dis->itemState & ODS_FOCUS) 
		DrawFocusRect(dis->hDC, &dis->rcItem); 
}
#endif

void plResponderProc::LoadState()
{
	fStatePB = (IParamBlock2*)fPB->GetReferenceTarget(kResponderState, 0, fCurState);

	IRemoveCmdRollups();
	LoadList();

	HWND hSwitchCombo = GetDlgItem(fhDlg, IDC_SWITCH_COMBO);
	ComboBox_SetCurSel(hSwitchCombo, fStatePB->GetInt(kStateCmdSwitch));
}

// THE MAGICAL TURDFEST.  Max's default RemapDir tries to always clone your referenced
// objects.  So when we reference an INode it wants to make a clone of that INode
// (and fails for some reason).  To get around this I just check if the object to be cloned
// is a paramblock, and actually clone it if it is.  Otherwise, I just return the object.
//
// UPDATE: Looks like it's only with ResponderComponents.  Probably the parentless PB's (which
// exist due to another bug).  Who cares, this works.
class MyRemapDir : public RemapDir
{
public:
	RefTargetHandle CloneRef(RefTargetHandle oldTarg)
	{
		if (oldTarg == NULL)
			return NULL;
		else if (oldTarg->SuperClassID() == PARAMETER_BLOCK2_CLASS_ID)
			return oldTarg->Clone(*this);
		else
			return oldTarg;
	}

	void PatchPointer(RefTargetHandle* patchThis, RefTargetHandle oldTarg) { hsAssert(0, "shit"); }
	RefTargetHandle FindMapping(RefTargetHandle from) { hsAssert(0, "shit"); return NULL; }
	void AddEntry(RefTargetHandle hfrom, RefTargetHandle hto) { hsAssert(0, "shit"); }
	void Backpatch() { hsAssert(0, "shit"); }
	void Clear() { hsAssert(0, "shit"); }
	void DeleteThis() { hsAssert(0, "shit"); }
	void AddPostPatchProc(PostPatchProc* proc, bool toDelete) { hsAssert(0, "shit"); }
};
// Even turdier - I had to define this to compile
RefTargetHandle RemapDir::CloneRef(RefTargetHandle oldTarg) { return NULL; }
static MyRemapDir gMyRemapDir;

RefTargetHandle plResponderComponent::Clone(RemapDir &remap)
{
	plComponentBase *obj = (plComponentBase*)fClassDesc->Create(false);
	// Do the base clone
	BaseClone(this, obj, remap);
	// Copy our references
	obj->ReplaceReference(kRefComp, fCompPB->Clone(gMyRemapDir));
	obj->ReplaceReference(kRefTargs, fTargsPB->Clone(remap));

	return obj;
}

BOOL plResponderProc::DlgProc(TimeValue t, IParamMap2 *pm, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	static UINT dragListMsg = 0;

	if (dragListMsg != 0 && msg == dragListMsg)
		if (DragListProc(hWnd, (DRAGLISTINFO*)lParam))
			return TRUE;

	switch (msg)
	{
	case WM_INITDIALOG:
		{
			if (!fhMenu)
				ICreateMenu();

			fhDlg = hWnd;
			fhList = GetDlgItem(fhDlg, IDC_CMD_LIST);
			fCurState = 0;
			fCmdIdx = -1;
			
			fPB = pm->GetParamBlock();
			fComp = (plResponderComponent*)fPB->GetOwner();

			fComp->IFixOldPB();

			LoadState();
			
			// Make it so the user can drag commands to different positions
			dragListMsg = RegisterWindowMessage(DRAGLISTMSGSTRING);
			MakeDragList(GetDlgItem(hWnd, IDC_CMD_LIST));

			// Setup the State Name combo
			HWND hStateName = GetDlgItem(hWnd, IDC_STATE_COMBO);
			ComboBox_LimitText(hStateName, 256);

// I give up, Windows doesn't want to tell me the real font size
#if 0//def CUSTOM_DRAW
			// TEMP
			HDC hDC = GetDC(hStateName);
			HFONT sysFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
			HFONT oldFont = SelectFont(hDC, sysFont);

			TEXTMETRIC tm;
			GetTextMetrics(hDC, &tm);
			ComboBox_SetItemHeight(hStateName, 0, tm.tmHeight+2);

			DeleteFont(SelectFont(hDC, oldFont));
			ReleaseDC(hStateName, hDC);
#endif

			// Add the commands
			int idx = ComboBox_AddString(hStateName, "Add State");
			ComboBox_SetItemData(hStateName, idx, kStateAdd);
			idx = ComboBox_AddString(hStateName, "Remove Current State");
			ComboBox_SetItemData(hStateName, idx, kStateRemove);
			idx = ComboBox_AddString(hStateName, "Set Current as Default");
			ComboBox_SetItemData(hStateName, idx, kStateDefault);
			idx = ComboBox_AddString(hStateName, "Copy Current State");
			ComboBox_SetItemData(hStateName, idx, kStateCopy);

			HWND hSwitchCombo = GetDlgItem(hWnd, IDC_SWITCH_COMBO);

			int numStates = fPB->Count(kResponderStateName);
			for (int i = 0; i < numStates; i++)
			{
				const char *stateName = fPB->GetStr(kResponderStateName, 0, i);
				char buf[128];
				if (!stateName || *stateName == '\0')
				{
					sprintf(buf, "State %d", i+1);
					stateName = buf;
				}
				ComboBox_InsertString(hStateName, i, stateName);
				ComboBox_AddString(hSwitchCombo, stateName);
			}

			ComboBox_SetCurSel(hStateName, fCurState);

			ComboBox_SetCurSel(hSwitchCombo, fStatePB->GetInt(kStateCmdSwitch));
		}
		return TRUE;

#ifdef CUSTOM_DRAW
	case WM_DRAWITEM:
		if (wParam == IDC_STATE_COMBO)
		{
			IDrawComboItem((DRAWITEMSTRUCT*)lParam);
			return TRUE;
		}
		break;
#endif

	case WM_SETCURSOR:
		{
			if (HIWORD(lParam) == WM_RBUTTONDOWN && HWND(wParam) == GetDlgItem(hWnd, IDC_CMD_LIST))
			{
				ICmdRightClick(HWND(wParam));
				return TRUE;
			}
		}
		break;
	
	case WM_COMMAND:
		if (HIWORD(wParam) == BN_CLICKED)
		{
			if (LOWORD(wParam) == IDC_ADD_ACTIVATOR)
			{
				// Adding an activator.  Set it and refresh the UI to show it in our list.
				plPick::Activator(fPB, kResponderActivators, false);
				pm->Invalidate(kResponderActivators);
				return TRUE;
			}
			else if (LOWORD(wParam) == IDC_ADD_CMD)
			{
				AddCommand();
				return TRUE;
			}
			// Remove the currently selected condition
			else if (LOWORD(wParam) == IDC_REMOVE_CMD)
			{
				RemoveCurCommand();
				return TRUE;
			}
		}
		else if (HIWORD(wParam) == LBN_SELCHANGE && LOWORD(wParam) == IDC_CMD_LIST)
		{
			ICreateCmdRollups();
			return TRUE;
		}
		else if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_SWITCH_COMBO)
		{
			int sel = ComboBox_GetCurSel((HWND)lParam);
			if (sel != CB_ERR)
				fStatePB->SetValue(kStateCmdSwitch, 0, sel);
		}
		else if (LOWORD(wParam) == IDC_STATE_COMBO)
		{
			HWND hCombo = (HWND)lParam;
			int code = HIWORD(wParam);

			// Disable accelerators when the combo has focus, so that new names can be typed in
			if (code == CBN_SETFOCUS)
			{
				plMaxAccelerators::Disable();
				return TRUE;
			}
			else if (code == CBN_KILLFOCUS)
			{
				plMaxAccelerators::Enable();
				return TRUE;
			}
			// State name changed, save it in the PB
			else if (code == CBN_EDITCHANGE)
			{
				char buf[256];
				ComboBox_GetText(hCombo, buf, sizeof(buf));
				const char *curName = fPB->GetStr(kResponderStateName, 0, fCurState);
				if (!curName || strcmp(buf, curName))
				{
					HWND hSwitch = GetDlgItem(hWnd, IDC_SWITCH_COMBO);
					int sel = ComboBox_GetCurSel(hSwitch);
					ComboBox_DeleteString(hSwitch, fCurState);
					ComboBox_InsertString(hSwitch, fCurState, buf);
					ComboBox_SetCurSel(hSwitch, sel);
					
					fPB->SetValue(kResponderStateName, 0, buf, fCurState);
					ComboBox_DeleteString(hCombo, fCurState);
					ComboBox_InsertString(hCombo, fCurState, buf);
//					ComboBox_SetCurSel(hCombo, fCurState);
				}

				return TRUE;
			}
			else if (code == CBN_SELCHANGE)
			{
				int sel = ComboBox_GetCurSel(hCombo);
				int type = ComboBox_GetItemData(hCombo, sel);

				if (type == kStateAdd)
				{
					IParamBlock2 *pb = CreateParameterBlock2(&gStateBlock, nil);
					fCurState = AddState(pb);
					fCmdIdx = -1;
				}
				else if (type == kStateRemove)
				{
					int count = fPB->Count(kResponderState);
					// Don't let the user remove the last state
					if (count == 1)
					{
						hsMessageBox("You must have at least one state.", "Error", hsMessageBoxNormal);
						ComboBox_SetCurSel(hCombo, fCurState);
						return TRUE;
					}
					// Verify that the user really wants to delete the state
					else
					{
						int ret = hsMessageBox("Are you sure you want to remove this state?", "Verify Remove", hsMessageBoxYesNo);
						if (ret == hsMBoxNo)
						{
							ComboBox_SetCurSel(hCombo, fCurState);
							return TRUE;
						}
					}

					fPB->Delete(kResponderState, fCurState, 1);
					fPB->Delete(kResponderStateName, fCurState, 1);

					ComboBox_DeleteString(hCombo, fCurState);
					ComboBox_SetCurSel(hCombo, 0);

					HWND hSwitch = GetDlgItem(hWnd, IDC_SWITCH_COMBO);
					ComboBox_DeleteString(hSwitch, fCurState);

					// If the deleted state was the default, set the default to the first
					int defState = fPB->GetInt(kResponderStateDef);
					if (fCurState == defState)
						fPB->SetValue(kResponderStateDef, 0, 0);
					else if (fCurState < defState)
						fPB->SetValue(kResponderStateDef, 0, defState-1);

					// Patch up the switch commands
					for (int i = fCurState; i < fPB->Count(kResponderState); i++)
					{
						IParamBlock2 *pb = (IParamBlock2*)fPB->GetReferenceTarget(kResponderState, 0, i);

						int switchState = pb->GetInt(kStateCmdSwitch);
						// TODO: might want to warn about this
						if (switchState == fCurState)
							pb->SetValue(kStateCmdSwitch, 0, 0);
						else if (switchState > fCurState)
							pb->SetValue(kStateCmdSwitch, 0, switchState-1);
					}

					fCurState = 0;
					fCmdIdx = -1;
				}
				else if (type == kStateDefault)
				{
					// Set the current state as the default
					fPB->SetValue(kResponderStateDef, 0, fCurState);
					ComboBox_SetCurSel(hCombo, fCurState);
				}
				else if (type == kStateCopy)
				{
					// Clone the state PB
					IParamBlock2 *origPB = (IParamBlock2*)fPB->GetReferenceTarget(kResponderState, 0, fCurState);
					IParamBlock2 *copyPB = (IParamBlock2*)origPB->Clone(gMyRemapDir);
					fCurState = AddState(copyPB);
					fCmdIdx = -1;
				}
				else
				{
					fCurState = sel;
					fCmdIdx = -1;
				}

				LoadState();

				return TRUE;
			}
		}
	}

	return FALSE;
}

void plResponderProc::ICmdRightClick(HWND hCmdList)
{
	// Get the position of the cursor in screen and tree client coords
	POINT point, localPoint;
	GetCursorPos(&point);
	localPoint = point;
	ScreenToClient(hCmdList, &localPoint);

	LRESULT res = SendMessage(hCmdList, LB_ITEMFROMPOINT, 0, MAKELPARAM(localPoint.x, localPoint.y));
	WORD index = LOWORD(res);
	if (index == WORD(LB_ERR))
		return;

	RECT rect;
	SendMessage(hCmdList, LB_GETITEMRECT, index, (LPARAM)&rect);

	// Make sure we're actually ON an item, LB_ITEMFROMPOINT get the closest instead of exact
	if (localPoint.y >= rect.top && localPoint.y <= rect.bottom)
	{
		BOOL enabled = fStatePB->GetInt(kStateCmdEnabled, 0, index);

		HMENU hMenu = CreatePopupMenu();
		AppendMenu(hMenu, MF_STRING, 1, enabled ? "Disable" : "Enable");

		SetForegroundWindow(fhDlg);
		int sel = TrackPopupMenu(hMenu, TPM_NONOTIFY | TPM_RETURNCMD, point.x, point.y, 0, fhDlg, NULL);
		if (sel == 1)
		{
			fStatePB->SetValue(kStateCmdEnabled, 0, !enabled, index);

			ListBox_DeleteString(hCmdList, index);
			ListBox_InsertString(hCmdList, index, GetCommandName(index));
		}

		DestroyMenu(hMenu);
	}
}

int plResponderProc::AddState(IParamBlock2 *pb)
{
	int idx = fPB->Append(kResponderState, 1, (ReferenceTarget**)&pb);
	pb->SetValue(kStateCmdSwitch, 0, idx);

	char *name = "";
	fPB->Append(kResponderStateName, 1, &name);

	HWND hCombo = GetDlgItem(fhDlg, IDC_STATE_COMBO);
	char buf[128];
	sprintf(buf, "State %d", idx+1);
	ComboBox_InsertString(hCombo, idx, buf);
	ComboBox_SetCurSel(hCombo, idx);

	HWND hSwitch = GetDlgItem(fhDlg, IDC_SWITCH_COMBO);
	ComboBox_AddString(hSwitch, buf);

	return idx;
}

void plResponderProc::MoveCommand(int oldIdx, int newIdx)
{
	// Move data
	int insertIdx = (newIdx > oldIdx) ? newIdx+1 : newIdx;
	int deleteIdx = (newIdx < oldIdx) ? oldIdx+1 : oldIdx;

	ReferenceTarget *targ = fStatePB->GetReferenceTarget(kStateCmdParams, 0, oldIdx);
	fStatePB->Insert(kStateCmdParams, insertIdx, 1, &targ);
	fStatePB->Delete(kStateCmdParams, deleteIdx, 1);

	ReferenceTarget *wait = fStatePB->GetReferenceTarget(kStateCmdWait, 0, oldIdx);
	fStatePB->Insert(kStateCmdWait, insertIdx, 1, &wait);
	fStatePB->Delete(kStateCmdWait, deleteIdx, 1);

	BOOL oldEnabled = fStatePB->GetInt(kStateCmdEnabled, 0, oldIdx);
	BOOL newEnabled = fStatePB->GetInt(kStateCmdEnabled, 0, newIdx);
	fStatePB->SetValue(kStateCmdEnabled, 0, oldEnabled, newIdx);
	fStatePB->SetValue(kStateCmdEnabled, 0, newEnabled, oldIdx);

	ResponderWait::CmdMoved(fStatePB, oldIdx, newIdx);

	LoadList();

	// Reselect item
	// (This doesn't send the LBN_SELCHANGE message so we do that manually)
	ListBox_SetCurSel(fhList, newIdx);
	ICreateCmdRollups();
}