/*==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 "plResponderGetComp.h"
#include <algorithm>
#include "MaxMain/plMaxNodeBase.h"
#include "resource.h"
#include "plComponentBase.h"
#include "MaxMain/plMaxAccelerators.h"
plResponderGetComp& plResponderGetComp::Instance()
{
static plResponderGetComp theInstance;
return theInstance;
}
bool plResponderGetComp::GetComp(IParamBlock2 *pb, int nodeID, int compID, ClassIDs *classIDs)
{
fPB = pb;
fNodeID = nodeID;
fCompID = compID;
fClassIDs = classIDs;
plMaxAccelerators::Disable();
int ret = DialogBox(hInstance,
MAKEINTRESOURCE(IDD_COMP_RESPOND_ANIMPICK),
GetCOREInterface()->GetMAXHWnd(),
ForwardDlgProc);
plMaxAccelerators::Enable();
return (ret != 0);
}
plComponentBase *plResponderGetComp::GetSavedComp(IParamBlock2 *pb, int nodeID, int compID, bool convertTime)
{
plMaxNodeBase *node = (plMaxNodeBase*)pb->GetReferenceTarget(nodeID);
// This value could be whack, only use if node is valid
plMaxNodeBase *comp = (plMaxNodeBase*)pb->GetReferenceTarget(compID);
if (!node || (convertTime && !node->CanConvert()) || !comp)
return nil;
int numComps = node->NumAttachedComponents();
for (int i = 0; i < numComps; i++)
{
plComponentBase *thisComp = node->GetAttachedComponent(i);
if (thisComp->GetINode() == comp)
return thisComp;
}
return nil;
}
void plResponderGetComp::IFindCompsRecur(plMaxNodeBase *node, NodeSet& nodes)
{
plComponentBase *comp = node->ConvertToComponent();
if (comp)
{
// If we're not filtering, or we are and this component is in our accepted list, add it
if (!fClassIDs ||
std::find(fClassIDs->begin(), fClassIDs->end(), comp->ClassID()) != fClassIDs->end())
{
nodes.insert(node);
}
}
for (int i = 0; i < node->NumberOfChildren(); i++)
IFindCompsRecur((plMaxNodeBase*)node->GetChildNode(i), nodes);
}
void plResponderGetComp::ILoadNodes(plMaxNodeBase *compNode, HWND hDlg)
{
HWND hNodes = GetDlgItem(hDlg, IDC_OBJ_LIST);
ListBox_ResetContent(hNodes);
plComponentBase *comp = compNode ? compNode->ConvertToComponent() : nil;
if (!comp)
return;
plMaxNodeBase *savedNode = (plMaxNodeBase*)fPB->GetReferenceTarget(fNodeID);
for (int i = 0; i < comp->NumTargets(); i++)
{
plMaxNodeBase *node = comp->GetTarget(i);
if (node)
{
int idx = ListBox_AddString(hNodes, node->GetName());
ListBox_SetItemData(hNodes, idx, node);
if (savedNode == node)
ListBox_SetCurSel(hNodes, idx);
}
}
}
BOOL CALLBACK plResponderGetComp::ForwardDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
return Instance().DlgProc(hDlg, msg, wParam, lParam);
}
BOOL plResponderGetComp::DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
{
NodeSet nodes;
IFindCompsRecur((plMaxNodeBase*)GetCOREInterface()->GetRootNode(), nodes);
HWND hComps = GetDlgItem(hDlg, IDC_COMP_LIST);
plMaxNodeBase *node = (plMaxNodeBase*)fPB->GetReferenceTarget(fCompID);
for (NodeSet::iterator it = nodes.begin(); it != nodes.end(); it++)
{
int idx = ListBox_AddString(hComps, (*it)->GetName());
ListBox_SetItemData(hComps, idx, *it);
if (*it == node)
ListBox_SetCurSel(hComps, idx);
}
ILoadNodes(node, hDlg);
}
return TRUE;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, 0);
return TRUE;
}
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDOK)
{
// Get the selected node
HWND hNode = GetDlgItem(hDlg, IDC_OBJ_LIST);
int idx = ListBox_GetCurSel(hNode);
plMaxNodeBase *node = nil;
if (idx != LB_ERR)
node = (plMaxNodeBase*)ListBox_GetItemData(hNode, idx);
// Get the selected component
HWND hComp = GetDlgItem(hDlg, IDC_COMP_LIST);
idx = ListBox_GetCurSel(hComp);
plMaxNodeBase *comp = nil;
if (idx != LB_ERR)
comp = (plMaxNodeBase*)ListBox_GetItemData(hComp, idx);
// If both were selected, save them in the PB and as the last setting
if (node && comp)
{
#if 0
if (fType == kFindAnim)
{
fLastAnimObj = obj->GetHandle();
fLastAnimComp = comp->GetHandle();
}
else if (fType == kFindSound)
{
fLastSoundObj = obj->GetHandle();
fLastSoundComp = comp->GetHandle();
}
#endif
fPB->SetValue(fNodeID, 0, (ReferenceTarget*)node);
fPB->SetValue(fCompID, 0, (ReferenceTarget*)comp);
EndDialog(hDlg, 1);
}
else
EndDialog(hDlg, 0);
return TRUE;
}
else if (HIWORD(wParam) == LBN_SELCHANGE)
{
if (LOWORD(wParam) == IDC_COMP_LIST)
{
int idx = ListBox_GetCurSel((HWND)lParam);
plMaxNodeBase *node = (plMaxNodeBase*)ListBox_GetItemData((HWND)lParam, idx);
ILoadNodes(node, hDlg);
}
}
break;
}
return FALSE;
}
///////////////////////////////////////////////////////////////////////////
#include "plPickNode.h"
void plResponderCompNode::Init(IParamBlock2 *pb, int compID, int nodeID, int compResID, int nodeResID, ClassIDs *compCIDs)
{
fPB = pb;
fCompID = compID;
fNodeID = nodeID;
fCompResID = compResID;
fNodeResID = nodeResID;
if (compCIDs)
fCompCIDs = *compCIDs;
}
void plResponderCompNode::InitDlg(HWND hWnd)
{
IValidate();
IUpdateNodeButton(hWnd);
IUpdateCompButton(hWnd);
}
bool plResponderCompNode::IValidate()
{
plMaxNodeBase *savedComp = (plMaxNodeBase*)fPB->GetReferenceTarget(fCompID);
plComponentBase *comp = savedComp ? savedComp->ConvertToComponent() : nil;
plMaxNodeBase *node = (plMaxNodeBase*)fPB->GetReferenceTarget(fNodeID);
if (comp && node)
{
// Make sure the selected comp has the correct CID
if (fCompCIDs.size() > 0)
{
Class_ID compCID = comp->ClassID();
bool foundCID = false;
for (int i = 0; i < fCompCIDs.size(); i++)
{
if (fCompCIDs[i] == compCID)
foundCID = true;
}
if (!foundCID)
{
fPB->SetValue(fCompID, 0, (INode*)nil);
fPB->SetValue(fNodeID, 0, (INode*)nil);
return false;
}
}
// Make sure the comp is really attached to the node
if (comp->IsTarget(node))
return true;
else
fPB->SetValue(fNodeID, 0, (INode*)nil);
}
return false;
}
void plResponderCompNode::CompButtonPress(HWND hWnd)
{
plPick::Node(fPB, fCompID, &fCompCIDs, true, false);
IUpdateCompButton(hWnd);
IUpdateNodeButton(hWnd);
}
void plResponderCompNode::NodeButtonPress(HWND hWnd)
{
plMaxNodeBase *node = (plMaxNodeBase*)fPB->GetReferenceTarget(fCompID);
plComponentBase *comp = node ? node->ConvertToComponent() : nil;
if (comp)
plPick::CompTargets(fPB, fNodeID, comp);
IUpdateNodeButton(hWnd);
}
void plResponderCompNode::IUpdateCompButton(HWND hWnd)
{
HWND hComp = GetDlgItem(hWnd, fCompResID);
plMaxNodeBase *savedComp = (plMaxNodeBase*)fPB->GetReferenceTarget(fCompID);
if (savedComp)
SetWindowText(hComp, savedComp->GetName());
else
SetWindowText(hComp, "(none)");
}
void plResponderCompNode::IUpdateNodeButton(HWND hWnd)
{
HWND hNode = GetDlgItem(hWnd, fNodeResID);
// If there is no component, disable the node button
plMaxNodeBase *node = (plMaxNodeBase*)fPB->GetReferenceTarget(fCompID);
plComponentBase *comp = node ? node->ConvertToComponent() : nil;
if (!comp)
{
EnableWindow(hNode, FALSE);
SetWindowText(hNode, "(none)");
return;
}
EnableWindow(hNode, TRUE);
plMaxNodeBase *objNode = (plMaxNodeBase*)fPB->GetReferenceTarget(fNodeID);
if (objNode && comp->IsTarget(objNode))
SetWindowText(hNode, objNode->GetName());
else
SetWindowText(hNode, "(none)");
}
bool plResponderCompNode::GetCompAndNode(plComponentBase*& comp, plMaxNodeBase*& node)
{
if (!IValidate())
{
comp = nil;
node = nil;
return false;
}
plMaxNodeBase *savedComp = (plMaxNodeBase*)fPB->GetReferenceTarget(fCompID);
comp = savedComp ? savedComp->ConvertToComponent() : nil;
node = (plMaxNodeBase*)fPB->GetReferenceTarget(fNodeID);
return true;
}