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

#include "plResponderLink.h"

class plResponderWaitProc;
extern plResponderWaitProc gResponderWaitProc;

enum
{
	kWaitWhoOld,
	kWaitPointOld,
	kWaitMe,
	kWaitWho,
	kWaitPoint,
};

ParamBlockDesc2 gResponderWaitBlock
(
	kResponderWaitBlk, _T("waitCmd"), 0, NULL, P_AUTO_UI,

	IDD_COMP_RESPOND_WAIT, IDS_COMP_WAIT, 0, 0, &gResponderWaitProc,

	kWaitWhoOld,	_T("whoOld"),		TYPE_INT_TAB, 0,		0, 0,
		end,

	kWaitPointOld,	_T("pointOld"),	TYPE_STRING_TAB, 0,		0, 0,
		end,

	kWaitMe,	_T("me"),		TYPE_BOOL,				0, 0,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_WAIT_ON_ME_CHECK,
		end,

	kWaitWho, _T("who"),		TYPE_INT,				0, 0,
		p_default,	-1,
		end,

	kWaitPoint, _T("point"),	TYPE_STRING,			0, 0,
		end,

	end
);
void ResponderWait::SetDesc(ClassDesc2 *desc) { gResponderWaitBlock.SetClassDesc(desc); }

void ResponderWait::FixupWaitBlock(IParamBlock2 *waitPB)
{
	if (waitPB->Count(kWaitWhoOld) > 0)
	{
		int who = waitPB->GetInt(kWaitWhoOld, 0, 0);
		waitPB->SetValue(kWaitWho, 0, who);
		waitPB->Delete(kWaitWhoOld, 0, 1);
	}

	if (waitPB->Count(kWaitPointOld) > 0)
	{
		TCHAR* point = waitPB->GetStr(kWaitPointOld, 0, 0);
		waitPB->SetValue(kWaitPoint, 0, point);
		waitPB->Delete(kWaitPointOld, 0, 1);
	}
}

IParamBlock2 *ResponderWait::CreatePB()
{
	return CreateParameterBlock2(&gResponderWaitBlock, nil);
}

bool ResponderWait::GetWaitOnMe(IParamBlock2* waitPB)
{
	return (waitPB->GetInt(kWaitMe) != 0);
}

int ResponderWait::GetWaitingOn(IParamBlock2* waitPB)
{
	return waitPB->GetInt(kWaitWho);
}

const char*	ResponderWait::GetWaitPoint(IParamBlock2* waitPB)
{
	const char* point = waitPB->GetStr(kWaitPoint);
	if (point && *point == '\0')
		return nil;
	return point;
}

class plResponderWaitProc : public ParamMap2UserDlgProc
{
protected:
	IParamBlock2 *fStatePB;
	IParamBlock2 *fWaitPB;

	int fCurCmd;
	HWND fhDlg;
	HWND fhList;

public:
	void Init(IParamBlock2 *curStatePB, int curCmd, HWND hList) { fStatePB = curStatePB; fCurCmd = curCmd; fhList = hList; }

	BOOL DlgProc(TimeValue t, IParamMap2 *pm, HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);

	void DeleteThis() {}

protected:
	void LoadWho(bool setDefault=false);
	void LoadPoint(bool force=false);

	IParamBlock2 *GetCmdParams(int cmdIdx);
};
static plResponderWaitProc gResponderWaitProc;

void ResponderWait::InitDlg(IParamBlock2 *curStatePB, int curCmd, HWND hList)
{
	gResponderWaitProc.Init(curStatePB, curCmd, hList);
}

IParamBlock2 *plResponderWaitProc::GetCmdParams(int cmdIdx)
{
	return (IParamBlock2*)fStatePB->GetReferenceTarget(kStateCmdParams, 0, cmdIdx);
}

BOOL plResponderWaitProc::DlgProc(TimeValue t, IParamMap2 *pm, HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
		case WM_INITDIALOG:
		{
			fhDlg = hDlg;

			fWaitPB = pm->GetParamBlock();

			ResponderWait::FixupWaitBlock(fWaitPB);

			IParamBlock2 *pb = GetCmdParams(fCurCmd);
			plResponderCmd *cmd = plResponderCmd::Find(pb);
			pm->Enable(kWaitMe, cmd->IsWaitable(pb));

			LoadWho();
			LoadPoint();
			return TRUE;
		}

		case WM_CUSTEDIT_ENTER:
			if (wParam == IDC_MARKER_EDIT)
			{
				ICustEdit *edit = GetICustEdit((HWND)lParam);
				char buf[256];
				edit->GetText(buf, sizeof(buf));
				fWaitPB->SetValue(kWaitPoint, 0, buf);

				return TRUE;
			}
			break;

		case WM_COMMAND:
		{
			int code = HIWORD(wParam);
			int id = LOWORD(wParam);

			if (id == IDC_CHECK_WAIT && code == BN_CLICKED)
			{
				BOOL checked = (IsDlgButtonChecked(hDlg, IDC_CHECK_WAIT) == BST_CHECKED);
				if (!checked)
				{
					fWaitPB->SetValue(kWaitWho, 0, -1);
					fWaitPB->SetValue(kWaitPoint, 0, "");

					LoadPoint();

					HWND hWho = GetDlgItem(hDlg, IDC_WAIT_WHO);
					EnableWindow(hWho, FALSE);
					ComboBox_ResetContent(hWho);
				}
				else
				{
					LoadWho(true);
					LoadPoint();
				}

				return TRUE;
			}
			else if (id == IDC_WAIT_WHO && code == CBN_SELCHANGE)
			{
				HWND hWho = (HWND)lParam;
				int who = ComboBox_GetCurSel(hWho);
				int idx = ComboBox_GetItemData(hWho, who);
				fWaitPB->SetValue(kWaitWho, 0, idx);

				LoadPoint();
				return TRUE;
			}
			else if (id == IDC_RADIO_FINISH && code == BN_CLICKED)
			{
				fWaitPB->SetValue(kWaitPoint, 0, "");
				LoadPoint();
				return TRUE;
			}
			else if (id == IDC_RADIO_POINT && code == BN_CLICKED)
			{
				LoadPoint(true);
				return TRUE;
			}
			else if (id == IDC_WAIT_POINT && code == CBN_SELCHANGE)
			{
				HWND hPoint = (HWND)lParam;
				if (ComboBox_GetCurSel(hPoint) != CB_ERR)
				{
					char buf[256];
					ComboBox_GetText(hPoint, buf, sizeof(buf));
					fWaitPB->SetValue(kWaitPoint, 0, buf);
				}
				return TRUE;
			}
			break;
		}
	}

	return FALSE;
}

void plResponderWaitProc::LoadWho(bool setDefault)
{
	HWND hWho = GetDlgItem(fhDlg, IDC_WAIT_WHO);
	int who = fWaitPB->GetInt(kWaitWho);

	ComboBox_ResetContent(hWho);

	int numFound = 0;

	// Copy all the commands before this one to the 'who' combo box
	for (int i = 0; i < fCurCmd; i++)
	{
		IParamBlock2 *pb = GetCmdParams(i);
		plResponderCmd *cmd = plResponderCmd::Find(pb);

		if (cmd->IsWaitable(pb))
		{
			int idx = ComboBox_AddString(hWho, cmd->GetInstanceName(pb));
			ComboBox_SetItemData(hWho, idx, i);

			// If the saved 'who' is valid, select it and check the wait checkbox
			if (who == i)
			{
				ComboBox_SetCurSel(hWho, idx);
				CheckDlgButton(fhDlg, IDC_CHECK_WAIT, BST_CHECKED);
				EnableWindow(hWho, TRUE);
			}

			numFound++;
		}
	}

	// Pick the last item in the who combo as the default
	if (setDefault && numFound > 0)
	{
		HWND hWho = GetDlgItem(fhDlg, IDC_WAIT_WHO);
		int idx = ComboBox_GetItemData(hWho, numFound-1);
		fWaitPB->SetValue(kWaitWho, 0, idx);

		ComboBox_SetCurSel(hWho, numFound-1);
		CheckDlgButton(fhDlg, IDC_CHECK_WAIT, BST_CHECKED);
		EnableWindow(hWho, TRUE);
	}

	// Disable the wait checkbox if there are no waitable commands behind this one
	EnableWindow(GetDlgItem(fhDlg, IDC_CHECK_WAIT), (numFound > 0));
}

void plResponderWaitProc::LoadPoint(bool force)
{
	int who = fWaitPB->GetInt(kWaitWho);
	const char *point = fWaitPB->GetStr(kWaitPoint);
	if (point && *point == '\0')
		point = nil;

	CheckRadioButton(fhDlg, IDC_RADIO_FINISH, IDC_RADIO_POINT, point || force ? IDC_RADIO_POINT : IDC_RADIO_FINISH);

	BOOL enableAll = (who != -1);
	EnableWindow(GetDlgItem(fhDlg, IDC_RADIO_FINISH), enableAll);
	EnableWindow(GetDlgItem(fhDlg, IDC_RADIO_POINT), enableAll);

	BOOL enablePoint = ((point != nil) || force) && enableAll;
	EnableWindow(GetDlgItem(fhDlg, IDC_WAIT_POINT), enablePoint);
	ComboBox_ResetContent(GetDlgItem(fhDlg, IDC_WAIT_POINT));

	if (enableAll)
	{
		IParamBlock2 *pb = (IParamBlock2*)fStatePB->GetReferenceTarget(kStateCmdParams, 0, who);
		plResponderCmd *cmd = plResponderCmd::Find(pb);

		// KLUDGE - stupid one-shot needs editable box
		if (cmd == &(plResponderCmdOneShot::Instance()))
		{
			ShowWindow(GetDlgItem(fhDlg, IDC_WAIT_POINT), SW_HIDE);

			HWND hEdit = GetDlgItem(fhDlg, IDC_MARKER_EDIT);
			ShowWindow(hEdit, SW_SHOW);
			ICustEdit *custEdit = GetICustEdit(hEdit);
			custEdit->SetText(point ? (char*)point : "");
		}
		else
		{
			ShowWindow(GetDlgItem(fhDlg, IDC_WAIT_POINT), SW_SHOW);

			HWND hEdit = GetDlgItem(fhDlg, IDC_MARKER_EDIT);
			ShowWindow(hEdit, SW_HIDE);

			plResponderCmd::WaitPoints waitPoints;
			cmd->GetWaitPoints(pb, waitPoints);

			HWND hCombo = GetDlgItem(fhDlg, IDC_WAIT_POINT);
			ComboBox_ResetContent(hCombo);

			if (waitPoints.size() == 0)
			{
				EnableWindow(GetDlgItem(fhDlg, IDC_RADIO_POINT), FALSE);
				EnableWindow(GetDlgItem(fhDlg, IDC_WAIT_POINT), FALSE);
			}
			else
			{
				for (int i = 0; i < waitPoints.size(); i++)
				{
					const char *marker = waitPoints[i].c_str();
					int idx = ComboBox_AddString(hCombo, marker);
					if (point && !strcmp(point, marker))
						ComboBox_SetCurSel(hCombo, idx);
				}
			}
		}
	}
}

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

void ResponderWait::CmdRemoved(IParamBlock2 *state, int delIdx)
{
	int numCmds = state->Count(kStateCmdParams);
	for (int i = delIdx; i < numCmds; i++)
	{
		IParamBlock2 *pb = GetWaitBlk(state, i);

		int who = pb->GetInt(kWaitWho);

		if (who == delIdx)
			pb->SetValue(kWaitWho, 0, -1);
		if (who > delIdx)
			pb->SetValue(kWaitWho, 0, who-1);
	}
}

// A command was moved from oldIdx to newIdx.  Fix all the wait commands.
void ResponderWait::CmdMoved(IParamBlock2 *state, int oldIdx, int newIdx)
{
	int numCmds = state->Count(kStateCmdParams);

	// Moved forward
	if (oldIdx < newIdx)
	{
		// Patch up the commands that were ahead of this one
		for (int i = oldIdx; i < numCmds; i++)
		{
			if (i == newIdx)
				continue;

			IParamBlock2 *pb = GetWaitBlk(state, i);

			int who = pb->GetInt(kWaitWho);

			// If the command was waiting on the moved one, and is now behind it, invalidate it
			if (who == oldIdx && i < newIdx)
				pb->SetValue(kWaitWho, 0, -1);
			//
			else if (who == oldIdx)
				pb->SetValue(kWaitWho, 0, newIdx);
			// If it was waiting on one ahead of it, correct the index
			else if (who > oldIdx && who <= newIdx)
				pb->SetValue(kWaitWho, 0, who-1);
		}
	}
	// Moved backward
	else
	{
		// If this command was waiting on any of the commands now ahead of it, invalidate it
		IParamBlock2 *movedPB = GetWaitBlk(state, newIdx);
		int who = movedPB->GetInt(kWaitWho);
		if (who >= newIdx)
			movedPB->SetValue(kWaitWho, 0, -1);

		for (int i = newIdx+1; i < numCmds; i++)
		{
			// Is this command waiting on any of the commands it is moving in back of?
			IParamBlock2 *pb = GetWaitBlk(state, i);
			int who = pb->GetInt(kWaitWho);
			if (who == oldIdx)
				pb->SetValue(kWaitWho, 0, newIdx);
			if (who >= newIdx && who < oldIdx)
				pb->SetValue(kWaitWho, 0, who+1);
		}
	}
}

// Determine if any of the wait commands will be invalidated by this move
bool ResponderWait::ValidateCmdMove(IParamBlock2 *state, int oldIdx, int newIdx)
{
	// Moving forward
	if (oldIdx < newIdx)
	{
		// Are any of the commands ahead of this one waiting on it?
		for (int i = oldIdx+1; i <= newIdx; i++)
		{
			IParamBlock2 *pb = GetWaitBlk(state, i);

			if (pb->GetInt(kWaitWho) == oldIdx)
			{
				int ret = hsMessageBox("You are moving this command ahead of another command that waits on it.\nAre you sure you want to do that?", "Warning", hsMessageBoxYesNo);
				if (ret == hsMBoxYes)
					return true;
				else
					return false;
			}
		}
	}
	// Moving backward
	else
	{
		// Is this command waiting on any of the commands it is moving in back of?
		IParamBlock2 *pb = GetWaitBlk(state, oldIdx);

		int who = pb->GetInt(kWaitWho);
		if (who >= newIdx && who < oldIdx)
		{
			int ret = hsMessageBox("You are moving this command behind another command that it is waiting on.\nAre you sure you want to do that?", "Warning", hsMessageBoxYesNo);
			if (ret == hsMBoxYes)
				return true;
			else
				return false;
		}
	}

	return true;
}