CWE-ou-minkata/Sources/Tools/MaxMain/plComponentPanel.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 "plComponentPanel.h"
#include "resource.h"

#include "plMaxNode.h"
#include "MaxComponent/plComponent.h"
#include "MaxComponent/plComponentMgr.h"
#include "plComponentDlg.h"
#include "plMaxAccelerators.h"

extern TCHAR *GetString(int id);

class ComponentUtilClassDesc : public ClassDesc
{
public:
    int             IsPublic()              { return TRUE; }
    void*           Create(BOOL loading)    { return &plComponentUtil::Instance(); }
    const TCHAR*    ClassName()             { return _T("Component Util"); }
    SClass_ID       SuperClassID()          { return UTILITY_CLASS_ID; }
    Class_ID        ClassID()               { return Class_ID(0xb220659, 0x31015552); }
    const TCHAR*    Category()              { return _T(""); }
};

static ComponentUtilClassDesc theComponentUtilCD;
ClassDesc* GetComponentUtilDesc() { return &theComponentUtilCD; }

plComponentUtil::plComponentUtil() : fInterface(nil), fhPanel(nil), fCurComponent(nil), fLastComponent(nil)
{
}

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

////////////////////////////////////////////////////////////////////////////////
// Proc for the currently selected object dialog
//
BOOL CALLBACK plComponentUtil::ForwardDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    return Instance().DlgProc(hDlg, msg, wParam, lParam);
}

BOOL plComponentUtil::DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_COMMAND:
        // Switch to next or previous target
        if (HIWORD(wParam) == BN_CLICKED && (LOWORD(wParam) == IDC_BACK || LOWORD(wParam) == IDC_FORWARD))
        {
            INextTarget(LOWORD(wParam) == IDC_FORWARD);
            return TRUE;
        }
        else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_REF_BY_BUTTON)
        {
            IShowRefdBy();
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            NMHDR *nmhdr = (NMHDR*)lParam;
            if (nmhdr->idFrom == IDC_COMPLIST)
            {
                switch (nmhdr->code)
                {
                // Stop Max from reading keypresses while the list has focus
                case NM_SETFOCUS:
                    plMaxAccelerators::Disable();
                    return TRUE;
                case NM_KILLFOCUS:
                    plMaxAccelerators::Enable();
                    return TRUE;

                case LVN_KEYDOWN:
                    {
                        NMLVKEYDOWN *kd = (NMLVKEYDOWN*)lParam;
                        if (kd->wVKey == VK_DELETE)
                            IDeleteListSelection();
                    }
                    return TRUE;

                // The edit box this creates kills the focus on the listbox,
                // so add an extra disable to ignore it
                case LVN_BEGINLABELEDIT:
                    plMaxAccelerators::Disable();
                    return TRUE;

                // Finishing changing the name of a component
                case LVN_ENDLABELEDIT:
                    {
                        NMLVDISPINFO *di = (NMLVDISPINFO*)lParam;
                        const char *name = di->item.pszText;

                        // If the name was changed...
                        if (name && *name != '\0')
                        {
                            // Update the name of the node
                            plComponentBase* comp = IGetListSelection();
                            comp->GetINode()->SetName(di->item.pszText);

                            // Make sure the column is wide enough
                            int width = ListView_GetStringWidth(nmhdr->hwndFrom, di->item.pszText)+10;
                            if (width > ListView_GetColumnWidth(nmhdr->hwndFrom, 0))
                            {
                                ListView_SetColumnWidth(nmhdr->hwndFrom, 0, width);
                                InvalidateRect(nmhdr->hwndFrom, NULL, FALSE);
                            }

                            // Update the name in the tree too
                            plComponentDlg::Instance().IUpdateNodeName((plMaxNode*)comp->GetINode());

                            // Return true to keep the changes
                            SetWindowLong(hDlg, DWL_MSGRESULT, TRUE);
                        }
                        
                        plMaxAccelerators::Enable();
                    }
                    return TRUE;

                // Selected component has changed.  This notification can come
                // more than necessary, so IAddRollups doesn't change the rollups
                // if the "new" one is the same as the old.
                case LVN_ITEMCHANGED:
                    {
                        plComponentBase* comp = IGetListSelection();
                        IAddRollups(comp);
                    }
                    return TRUE;
                }
            }
        }
        break;
    }

    return FALSE;
}

void plComponentUtil::IDeleteListSelection()
{
    plComponentBase* comp = IGetListSelection();
    if (comp)
    {
        // Delete each of the selected nodes from this components target list
        int count = fInterface->GetSelNodeCount();
        for (int i = 0; i < count; i++)
        {
            plMaxNode *curNode = (plMaxNode*)fInterface->GetSelNode(i);
            comp->DeleteTarget(curNode);
        }

        IUpdateRollups();
    }
}

plComponentBase* plComponentUtil::IGetListSelection()
{
    HWND hList = GetDlgItem(fhPanel, IDC_COMPLIST);

    int index = ListView_GetNextItem(hList, -1, LVNI_SELECTED);
    if (index != -1)
    {
        LVITEM item;
        item.mask = LVIF_PARAM;
        item.iItem = index;
        item.iSubItem = 0;
        if (ListView_GetItem(hList, &item))
            return (plComponentBase*)item.lParam;
    }

    return nil;
}

void plComponentUtil::BeginEditParams(Interface *ip, IUtil *iu)
{
    fInterface = ip;
    
    fhPanel = fInterface->AddRollupPage(hInstance, MAKEINTRESOURCE(IDD_COMP_PANEL), ForwardDlgProc, "Components (Selected Obj)");

    // Add a column.  We don't use it (graphically), but it has to be there.
    HWND hList = GetDlgItem(fhPanel, IDC_COMPLIST);
    LVCOLUMN lvc;
    lvc.mask = LVCF_TEXT;
    lvc.pszText = "Description";
    ListView_InsertColumn(hList, 0, &lvc);

    IUpdateRollups();
}

void plComponentUtil::EndEditParams(Interface *ip, IUtil *iu)
{
    IDestroyRollups();

    GetCOREInterface()->DeleteRollupPage(fhPanel);
    fhPanel = nil;
    fCurComponent = nil;
    fInterface = nil;
}

void plComponentUtil::SelectionSetChanged(Interface *ip, IUtil *iu)
{
    IUpdateRollups();
}

void plComponentUtil::IUpdateRollups()
{
    if (!fhPanel)
        return;
    
    // Destroy any current rollups
    IDestroyRollups();

    HWND hList = GetDlgItem(fhPanel, IDC_COMPLIST);
    ListView_DeleteAllItems(hList);

    // Check that something is selected.
    int nodeCount = fInterface->GetSelNodeCount();
    if (nodeCount == 0)
    {
        IAddRollups(nil);
        return;
    }

    // Get the components shared among the selected nodes
    int i;
    INodeTab selNodes;
    selNodes.SetCount(nodeCount);
    for (i = 0; i < nodeCount; i++)
        selNodes[i] = fInterface->GetSelNode(i);

    INodeTab sharedComps;
    plSharedComponents(selNodes, sharedComps);

    // Add the shared components to the list
    for (i = 0; i < sharedComps.Count(); i++)
    {
        plComponentBase *comp = ((plMaxNode*)sharedComps[i])->ConvertToComponent();

        if (plComponentDlg::Instance().IIsHidden(comp->ClassID()))
            continue;

        IParamBlock2 *pb = comp->GetParamBlockByID(plComponent::kBlkComp);

        LVITEM item = {0};
        item.mask = LVIF_TEXT | LVIF_PARAM;
        item.pszText = sharedComps[i]->GetName();
        item.iItem = ListView_GetItemCount(hList);
        item.lParam = (LPARAM)comp;
        ListView_InsertItem(hList, &item);
    }

    // Make sure the column is wide enough
    ListView_SetColumnWidth(hList, 0, LVSCW_AUTOSIZE);

    // If there are rollups to show
    if (ListView_GetItemCount(hList) > 0)
    {
        // Try and find the last used rollup
        int idx = IFindListItem(fLastComponent);

        // If last one wasn't found, just use the first
        if (idx == -1)
            idx = 0;

        ListView_SetItemState(hList, idx, LVIS_SELECTED, LVIS_SELECTED);
        ListView_EnsureVisible(hList, idx, FALSE);
    }
    else
        IAddRollups(nil);
}

int plComponentUtil::IFindListItem(plComponentBase* comp)
{
    LVFINDINFO fi;
    fi.flags = LVFI_PARAM;
    fi.lParam = (LPARAM)comp;
    return ListView_FindItem(GetDlgItem(fhPanel, IDC_COMPLIST), -1, &fi);
}

#include "../MaxComponent/plAutoUIComp.h"

void plComponentUtil::IAddRollups(plComponentBase* comp)
{
    if (fCurComponent == comp)
        return;

    IDestroyRollups();
    fCurComponent = comp;
    if (comp)
        fLastComponent = comp;

    //
    // Update the targets dialog
    //
    UInt32 numTargs = 0;
    if (fCurComponent)
    {
        // Only count non-nil targets
        for (UInt32 i = 0; i < fCurComponent->NumTargets(); i++)
            if (fCurComponent->GetTarget(i))
                numTargs++;
    }

    // Put the number of targets in the text box
    char buf[12];
    itoa(numTargs, buf, 10);
    SetWindowText(GetDlgItem(fhPanel, IDC_NUM_TARGS), buf);

    // Enable the forward/back buttons if there are multiple targets
    BOOL useButtons = (numTargs > 1);
    EnableWindow(GetDlgItem(fhPanel, IDC_BACK), useButtons);
    EnableWindow(GetDlgItem(fhPanel, IDC_FORWARD), useButtons);

    //
    // Add the component rollups
    //
    if (fCurComponent)
        fCurComponent->CreateRollups();
}

void plComponentUtil::IDestroyRollups()
{
    if (fCurComponent)
        fCurComponent->DestroyRollups();
}

void plComponentUtil::INextTarget(bool forward)
{
//  fCurComponent = IGetListSelection();
//  plComponentBase *comp = fCurComponent->ConvertToComponent();

    // Loop through the selected component's targets until we find the currently selected node.
    // This gives us a starting point to find the next or previous target in this component's list.
    plMaxNode *curNode = (plMaxNode*)GetCOREInterface()->GetSelNode(0);
    UInt32 count = fCurComponent->NumTargets();
    for (UInt32 i = 0; i < count; i++)
    {
        if (fCurComponent->GetTarget(i) == curNode)
        {
            // Got to loop until the target is non-nil here, so we skip over
            // any deleted nodes.
            UInt32 targIdx = i;
            do
            {
                // Figure out which target to change to
                if (forward)
                {
                    if (targIdx == count-1)
                        targIdx = 0;
                    else
                        targIdx = targIdx + 1;
                }
                else
                {
                    if (targIdx == 0)
                        targIdx = count-1;
                    else
                        targIdx = targIdx - 1;
                }
            } while (!fCurComponent->GetTarget(targIdx));

            // Select the new target
            theHold.Begin();
            fInterface->RedrawViews(fInterface->GetTime(), REDRAW_BEGIN);

            fInterface->SelectNode(fCurComponent->GetTarget(targIdx));

            fInterface->RedrawViews(fInterface->GetTime(), REDRAW_END);
            theHold.Accept("Select");

            return;
        }
    }
}

void plComponentUtil::IUpdateNodeName(plMaxNode *node)
{
    if (!fhPanel)
        return;

    // Update the name in the list
    int idx = IFindListItem(node->ConvertToComponent());
    if (idx != -1)
    {
        HWND hList = GetDlgItem(fhPanel, IDC_COMPLIST);
        ListView_SetItemText(hList, idx, 0, node->GetName());
        // Make sure the column is wide enough
        ListView_SetColumnWidth(hList, 0, LVSCW_AUTOSIZE);
    }
}

void plComponentUtil::IComponentPreDelete(plComponentBase* comp)
{
    if (fCurComponent == comp)
    {
        IDestroyRollups();
        fCurComponent = nil;
    }
}

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

#include <vector>

void IGetReferencesRecur(plMaxNode* node, INode* target, std::vector<plMaxNode*>& nodes)
{
    plComponentBase* comp = node->ConvertToComponent();
    if (comp && comp->DoReferenceNode(target))
    {
        const char* name = node->GetName();
        nodes.push_back(node);
    }

    for (int i = 0; i < node->NumberOfChildren(); i++)
    {
        IGetReferencesRecur((plMaxNode*)node->GetChildNode(i), target, nodes);
    }
}

BOOL CALLBACK RefDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        {
            if (GetCOREInterface()->GetSelNodeCount() > 0)
            {
                INode* node = GetCOREInterface()->GetSelNode(0);

                char buf[256];
                sprintf(buf, "%s is Ref'd By", node->GetName());
                SetWindowText(hDlg, buf);

                std::vector<plMaxNode*> nodes;
                IGetReferencesRecur((plMaxNode*)GetCOREInterface()->GetRootNode(), node, nodes);

                HWND hList = GetDlgItem(hDlg, IDC_REF_LIST);
                for (int i = 0; i < nodes.size(); i++)
                {
                    plMaxNode* node = nodes[i];
                    int idx = ListBox_AddString(hList, node->GetName());
                    ListBox_SetItemData(hList, idx, node);
                }
            }
        }
        return TRUE;

    case WM_COMMAND:
        if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_CLOSE)
        {
            EndDialog(hDlg, 0);
            return TRUE;
        }
        else if (HIWORD(wParam) == LBN_DBLCLK && LOWORD(wParam) == IDC_REF_LIST)
        {
            // If the user double clicked on a component, return it so we can
            // select the nodes it's attached to
            HWND hList = HWND(lParam);
            int sel = ListBox_GetCurSel(hList);
            LRESULT node = ListBox_GetItemData(hList, sel);
            EndDialog(hDlg, node);
            return TRUE;
        }
        break;
    }

    return FALSE;
}

void plComponentUtil::IShowRefdBy()
{
    INode* node = (INode*)DialogBox(hInstance,
                                    MAKEINTRESOURCE(IDD_REF_BY),
                                    GetCOREInterface()->GetMAXHWnd(),
                                    RefDlgProc);
    if (node)
    {
        INodeTab nodes;
        nodes.Append(1, &node);
        plComponentDlg::Instance().SelectComponentTargs(nodes);
    }
}