CWE-ou-minkata/Sources/Tools/MaxComponent/plPickNodeBase.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 "plPickNodeBase.h"

#include "../MaxMain/plMaxNode.h"
#include "plComponentBase.h"
#include "resource.h"
#include "../MaxMain/plMaxAccelerators.h"

#include <algorithm>

plPickNodeBase::plPickNodeBase(IParamBlock2* pb, int nodeParamID) : fPB(pb), fNodeParamID(nodeParamID)
{
}


bool plPickNodeBase::DoPick()
{
    plMaxAccelerators::Disable();

    // Create Dlg
    BOOL ret = DialogBoxParam(hInstance,
                            MAKEINTRESOURCE(IDD_PICK_NODE),
                            GetCOREInterface()->GetMAXHWnd(),
                            IDlgProc,
                            (LPARAM)this);

    plMaxAccelerators::Enable();

    return (ret != 0);
}

void plPickNodeBase::IInitDlg(HWND hDlg)
{
    HWND hList = GetDlgItem(hDlg, IDC_NODE_LIST);

//  int idx = ListBox_AddString(hList, kUserTypeNone);
//  ListBox_SetCurSel(hList, idx);

    IAddUserType(hList);

//  LONG style = GetWindowLong(hList, GWL_STYLE);
//  SetWindowLong(hList, GWL_STYLE, style | LBS_MULTIPLESEL);

    plMaxNode* curSelNode = nil;
    ParamType2 type = fPB->GetParameterType(fNodeParamID);
    if (type == TYPE_REFTARG)
        curSelNode = (plMaxNode*)fPB->GetReferenceTarget(fNodeParamID);
    else if (type == TYPE_INODE)
        curSelNode = (plMaxNode*)fPB->GetINode(fNodeParamID);

    IGetNodesRecur((plMaxNode*)GetCOREInterface()->GetRootNode(), hList, curSelNode);
}

BOOL plPickNodeBase::IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static plPickNodeBase* pthis = nil;

    switch (msg)
    {
    case WM_INITDIALOG:
        pthis = (plPickNodeBase*)lParam;
        pthis->IInitDlg(hDlg);
        return TRUE;

    case WM_COMMAND:
        // For 'OK' or double-click, get the selected node and exit
        if ((HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDOK) ||
            (HIWORD(wParam) == LBN_DBLCLK && LOWORD(wParam) == IDC_NODE_LIST))
        {
            pthis->IGetSelNode(GetDlgItem(hDlg, IDC_NODE_LIST));
            EndDialog(hDlg, 1);
            return TRUE;
        }
        else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, 0);
            return TRUE;
        }
        break;
    }

    return FALSE;
}

void plPickNodeBase::IGetNodesRecur(plMaxNode* node, HWND hList, plMaxNode* curSelNode)
{
    if (node)
    {
        if (ICheckNode(node))
        {
            int idx = ListBox_AddString(hList, node->GetName());
            ListBox_SetItemData(hList, idx, node);

            if (node == curSelNode)
                ListBox_SetCurSel(hList, idx);
        }

        int numChildren = node->NumberOfChildren();
        for (int i = 0; i < numChildren; i++)
        {
            IGetNodesRecur((plMaxNode*)node->GetChildNode(i), hList, curSelNode);
        }
    }
}

void plPickNodeBase::ISetNodeValue(plMaxNode* node)
{
    ParamType2 type = fPB->GetParameterType(fNodeParamID);
    if (type == TYPE_REFTARG)
    {
        fPB->SetValue(fNodeParamID, 0, (ReferenceTarget*)node);
    }
//  else if (type == TYPE_REFTARG_TAB)
//  {
//  }
    else if (type == TYPE_INODE)
    {
        fPB->SetValue(fNodeParamID, 0, (INode*)node);
    }
//  else if (type == TYPE_INODE_TAB)
//  {
//  }
}

void plPickNodeBase::IGetSelNode(HWND hList)
{
    int sel = ListBox_GetCurSel(hList);
    if (sel == LB_ERR)
        return;

    plMaxNode* node = (plMaxNode*)ListBox_GetItemData(hList, sel);

    if (node)
    {
        ISetNodeValue(node);
        ISetUserType(node, nil);
    }
    else
    {
        int len = ListBox_GetTextLen(hList, sel);
        char* buf = TRACKED_NEW char[len+1];
        ListBox_GetText(hList, sel, buf);

/*      if (!strcmp(buf, kUserTypeNone))
        {
            ISetNodeValue(nil);
            ISetUserType(nil, nil);
        }
        else
*/          ISetUserType(nil, buf);

        delete [] buf;
    }
}

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

plPickNode::plPickNode(IParamBlock2* pb, int nodeParamID) :
    plPickNodeBase(pb, nodeParamID)
{
}

bool plPickNode::ICanConvertToType(Object *obj)
{
    for (int i = 0; i < fCIDs.size(); i++)
    {
        if (obj->CanConvertToType(fCIDs[i]))
            return true;
    }

    return false;
}

bool plPickNode::ICheckNode(plMaxNode* node)
{
    if (node->GetObjectRef())
    {
        // Not filtering by ClassID and node is hidden or frozen
        if (fCIDs.size() == 0 && (node->IsHidden() || node->IsFrozen()))
            return false;

        // We aren't filtering by ClassID or we are and we found a match
        if (fCIDs.size() == 0 ||
            (fCanConvertToType && ICanConvertToType(node->GetObjectRef()) ||
            std::find(fCIDs.begin(), fCIDs.end(), node->GetObjectRef()->ClassID()) != fCIDs.end()))
        {
            // Don't allow a ref to ourselves (a cyclical reference)
            if (fPB->GetOwner() == node)
                return false;

            // Approved and not in the list, add it
            return true;
        }
    }

    return false;
}

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

plPickMtlNode::plPickMtlNode(IParamBlock2* pb, int nodeParamID, Mtl* mtl) :
    plPickNodeBase(pb, nodeParamID), fMtl(mtl)
{
}

bool plPickMtlNode::ICheckNode(plMaxNode* node)
{
    // Filtering by nodes with a specific material on them
    if (fMtl && node->GetMtl() == fMtl)
        return true;
    return false;
}

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

plPickCompNode::plPickCompNode(IParamBlock2* pb, int nodeParamID, plComponentBase* comp) :
    plPickNodeBase(pb, nodeParamID), fComp(comp)
{
}

bool plPickCompNode::ICheckNode(plMaxNode* node)
{
    // Filtering by nodes a component is attached to
    if (fComp && fComp->IsTarget((plMaxNodeBase*)node))
        return true;

    return false;
}