OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
72 Commits
80 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 98834d4a12
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '98834d4a12'
${ noResults }
CWE-ou-minkata/Sources/Tools/MaxMain/plComponentDlg.cpp

1027 lines
31 KiB
Raw Blame History

/*==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 "max.h"
#include "iparamb2.h"
#include "plComponentDlg.h"
#include "../MaxComponent/plComponentBase.h"
#include "../MaxComponent/plComponentMgr.h"
#include "../MaxComponent/plComponentReg.h"
#include "resource.h"
#include "plMaxNode.h"
#include "plComponentPanel.h"
#include "plMaxAccelerators.h"
#include <algorithm>
extern HINSTANCE hInstance;
plComponentDlg::plComponentDlg() : fhDlg(nil), fCompMenu(nil), fTypeMenu(nil), fCommentNode(nil)
{
fInterface = GetCOREInterface();
RegisterNotification(INotify, 0, NOTIFY_FILE_PRE_OPEN);
RegisterNotification(INotify, 0, NOTIFY_SYSTEM_PRE_NEW);
RegisterNotification(INotify, 0, NOTIFY_SYSTEM_PRE_RESET);
RegisterNotification(INotify, 0, NOTIFY_FILE_PRE_MERGE);
RegisterNotification(INotify, 0, NOTIFY_PRE_IMPORT);
RegisterNotification(INotify, 0, NOTIFY_FILE_PRE_SAVE);
RegisterNotification(INotify, 0, NOTIFY_FILE_PRE_SAVE_OLD);
RegisterNotification(INotify, 0, NOTIFY_FILE_POST_OPEN);
RegisterNotification(INotify, 0, NOTIFY_SYSTEM_POST_NEW);
RegisterNotification(INotify, 0, NOTIFY_SYSTEM_POST_RESET);
RegisterNotification(INotify, 0, NOTIFY_FILE_POST_MERGE);
RegisterNotification(INotify, 0, NOTIFY_POST_IMPORT);
RegisterNotification(INotify, 0, NOTIFY_SYSTEM_SHUTDOWN);
}
plComponentDlg::~plComponentDlg()
{
if (fhDlg)
{
fInterface->UnRegisterDlgWnd(fhDlg);
DestroyWindow(fhDlg);
}
if (fCompMenu)
DestroyMenu(fCompMenu);
if (fTypeMenu)
DestroyMenu(fTypeMenu);
}
plComponentDlg& plComponentDlg::Instance()
{
static plComponentDlg theInstance;
return theInstance;
}
void plComponentDlg::Open()
{
if (!fhDlg)
{
fhDlg = CreateDialog(hInstance,
MAKEINTRESOURCE(IDD_COMP_MAIN),
GetCOREInterface()->GetMAXHWnd(),
ForwardDlgProc);
GetWindowRect(fhDlg, &fLastRect);
fSmallestSize.x = fLastRect.right - fLastRect.left;
fSmallestSize.y = fLastRect.bottom - fLastRect.top;
RECT rect;
memcpy(&rect, &fLastRect, sizeof(RECT));
rect.right = rect.left + 235;
rect.bottom = rect.top + 335;
IPositionControls(&rect, WMSZ_BOTTOM);
SetWindowPos(fhDlg, NULL, 0, 0, rect.right - rect.left, rect.bottom - rect.top, SWP_NOMOVE | SWP_NOZORDER);
}
fInterface->RegisterDlgWnd(fhDlg);
ShowWindow(fhDlg, SW_SHOW);
if (IsIconic(fhDlg))
ShowWindow(fhDlg, SW_RESTORE);
}
void plComponentDlg::IPositionControls(RECT *newRect, int edge)
{
// Get the new width and height
int newW = newRect->right - newRect->left;
int newH = newRect->bottom - newRect->top;
// If an edge we don't support is being dragged, don't allow the resize.
if (!(edge == WMSZ_BOTTOM ||
edge == WMSZ_BOTTOMRIGHT ||
edge == WMSZ_RIGHT))
{
memcpy(newRect, &fLastRect, sizeof(RECT));
return;
}
// If the width or height is too small, set it to the minimum
if (newW < fSmallestSize.x)
newRect->right = newRect->left + fSmallestSize.x;
if (newH < fSmallestSize.y)
newRect->bottom = newRect->top + fSmallestSize.y;
// Calculate the new width and height
int hDiff = (newRect->bottom - newRect->top) - (fLastRect.bottom - fLastRect.top);
int wDiff = (newRect->right - newRect->left) - (fLastRect.right - fLastRect.left);
// Copy our new rect to the last rect
memcpy(&fLastRect, newRect, sizeof(RECT));
// If the size has changed, reposition and resize controls
if (hDiff != 0 || wDiff != 0)
{
IPositionControl(GetDlgItem(fhDlg, IDC_TREE), hDiff, wDiff, kResizeX | kResizeY);
IPositionControl(GetDlgItem(fhDlg, IDC_COMMENT_TEXT), hDiff);
IPositionControl(GetDlgItem(fhDlg, IDC_COMMENTS), hDiff, wDiff, kResizeX | kMoveY);
IPositionControl(GetDlgItem(fhDlg, IDC_ATTACH), hDiff);
}
InvalidateRect(fhDlg, NULL, TRUE);
}
void plComponentDlg::IPositionControl(HWND hControl, int hDiff, int wDiff, int flags)
{
RECT rect;
GetWindowRect(hControl, &rect);
hsAssert(!((flags & kMoveX) & (flags & kResizeX)), "Moving AND resizing in X in IPositionControl");
hsAssert(!((flags & kMoveY) & (flags & kResizeY)), "Moving AND resizing in Y in IPositionControl");
if (flags & kMoveX || flags & kMoveY)
{
POINT pos = { rect.left, rect.top };
ScreenToClient(fhDlg, &pos);
if (flags & kMoveX)
pos.x += wDiff;
if (flags & kMoveY)
pos.y += hDiff;
SetWindowPos(hControl, NULL, pos.x, pos.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOREDRAW);
}
if (flags & kResizeX || flags & kResizeY)
{
int w = rect.right - rect.left;
int h = rect.bottom - rect.top;
if (flags & kResizeX)
w += wDiff;
if (flags & kResizeY)
h += hDiff;
SetWindowPos(hControl, NULL, 0, 0, w, h, SWP_NOMOVE | SWP_NOZORDER | SWP_NOREDRAW);
}
}
void plComponentDlg::IGetComment()
{
if (fCommentNode)
{
// Get the text from the edit and store it in the UserPropBuffer
int len = GetWindowTextLength(GetDlgItem(fhDlg, IDC_COMMENTS))+1;
if (len != 0)
{
char *buf = TRACKED_NEW char[len];
GetDlgItemText(fhDlg, IDC_COMMENTS, buf, len);
fCommentNode->SetUserPropBuffer(buf);
delete [] buf;
}
else
fCommentNode->SetUserPropBuffer("");
}
}
BOOL plComponentDlg::ForwardDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
return Instance().DlgProc(hDlg, msg, wParam, lParam);
}
#define MENU_ID_START 41000
BOOL plComponentDlg::DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
fhDlg = hDlg;
IAddComponentsRecur(GetDlgItem(hDlg, IDC_TREE), (plMaxNode*)GetCOREInterface()->GetRootNode());
ICreateMenu();
ICreateRightClickMenu();
return TRUE;
case WM_SIZING:
IPositionControls((RECT*)lParam, wParam);
return TRUE;
case WM_ACTIVATE:
if (LOWORD(wParam) == WA_INACTIVE)
plMaxAccelerators::Enable();
else
plMaxAccelerators::Disable();
return TRUE;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDCANCEL)
{
ShowWindow(hDlg, SW_HIDE);
fInterface->UnRegisterDlgWnd(hDlg);
return TRUE;
}
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_ATTACH)
{
IAttachTreeSelection();
return TRUE;
}
else if (HIWORD(wParam) == EN_KILLFOCUS && LOWORD(wParam) == IDC_COMMENTS)
{
IGetComment();
return TRUE;
}
// "Refresh" menu item
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == ID_REFRESH)
{
IRefreshTree();
return TRUE;
}
// "Remove unused components" menu item
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == ID_REMOVE_UNUSED)
{
IRemoveUnusedComps();
return TRUE;
}
// Item selected from 'New' menu
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) >= MENU_ID_START)
{
ClassDesc *desc = plComponentMgr::Inst().Get(LOWORD(wParam)-MENU_ID_START);
// If this is a component type (not a category)
if (desc)
{
// Create an object of that type and a node to reference it
Object *obj = (Object*)GetCOREInterface()->CreateInstance(desc->SuperClassID(), desc->ClassID());
INode *node = GetCOREInterface()->CreateObjectNode(obj);
plComponentBase *comp = (plComponentBase*)obj;
node->Hide(!comp->AllowUnhide());
node->Freeze(TRUE);
// Add the new component to the tree
HWND hTree = GetDlgItem(hDlg, IDC_TREE);
HTREEITEM item = IAddComponent(hTree, (plMaxNode*)node);
TreeView_SelectItem(hTree, item);
TreeView_EnsureVisible(hTree, item);
}
}
break;
case WM_NOTIFY:
NMHDR *nmhdr = (NMHDR*)lParam;
if (nmhdr->idFrom == IDC_TREE)
{
switch (nmhdr->code)
{
case TVN_SELCHANGED:
{
NMTREEVIEW *tv = (NMTREEVIEW*)lParam;
IGetComment();
bool isComponent = IIsComponent(tv->itemNew.lParam);
// If the new selection is a component, enable the attach button and comment field
EnableWindow(GetDlgItem(hDlg, IDC_ATTACH), isComponent);
SendDlgItemMessage(hDlg, IDC_COMMENTS, EM_SETREADONLY, !isComponent, 0);
if (isComponent)
{
fCommentNode = (plMaxNode*)tv->itemNew.lParam;
TSTR buf;
fCommentNode->GetUserPropBuffer(buf);
SetDlgItemText(hDlg, IDC_COMMENTS, buf);
}
else
{
fCommentNode = nil;
SetDlgItemText(hDlg, IDC_COMMENTS, "");
}
return TRUE;
}
break;
case TVN_BEGINLABELEDIT:
// If this isn't a component, don't allow the edit
if (!IIsComponent(((NMTVDISPINFO*)lParam)->item.lParam))
{
SetWindowLong(hDlg, DWL_MSGRESULT, TRUE);
return TRUE;
}
// The edit box this creates kills the focus on our window, causing
// accelerators to be enabled. Add an extra disable to counteract that.
plMaxAccelerators::Disable();
return TRUE;
// Finishing changing the name of a component
case TVN_ENDLABELEDIT:
{
NMTVDISPINFO *di = (NMTVDISPINFO*)lParam;
char* text = di->item.pszText;
// If the name was changed...
if (text && *text != '\0')
{
// Update the name of the node
plMaxNode *node = IGetTreeSelection();
node->SetName(text);
// Update the name in the panel too
if (plComponentUtil::Instance().IsOpen())
plComponentUtil::Instance().IUpdateNodeName(node);
// Make sure Max knows the file was changed
SetSaveRequiredFlag();
// Return true to keep the changes
SetWindowLong(hDlg, DWL_MSGRESULT, TRUE);
}
plMaxAccelerators::Enable();
}
return TRUE;
// User double-clicked. Select the objects the selected component is attached to.
case NM_DBLCLK:
ISelectTreeSelection();
return TRUE;
case NM_RCLICK:
IOpenRightClickMenu();
return TRUE;
case TVN_KEYDOWN:
// User pressed delete
if (((NMTVKEYDOWN*)lParam)->wVKey == VK_DELETE)
{
IDeleteComponent(IGetTreeSelection());
return TRUE;
}
break;
}
}
break;
}
return FALSE;
}
HTREEITEM plComponentDlg::IAddLeaf(HWND hTree, HTREEITEM hParent, const char *text, LPARAM lParam)
{
TVITEM tvi = {0};
tvi.mask = TVIF_TEXT | TVIF_PARAM;
tvi.pszText = (char*)text;
tvi.cchTextMax = strlen(text);
tvi.lParam = lParam;
TVINSERTSTRUCT tvins = {0};
tvins.item = tvi;
tvins.hParent = hParent;
tvins.hInsertAfter = TVI_SORT;
return TreeView_InsertItem(hTree, &tvins);
}
HTREEITEM plComponentDlg::IFindTreeItem(HWND hTree, const char *name, HTREEITEM hParent)
{
HTREEITEM hChild = TreeView_GetChild(hTree, hParent);
while (hChild)
{
char buf[256];
TVITEM tvi;
tvi.mask = TVIF_TEXT;
tvi.hItem = hChild;
tvi.pszText = buf;
tvi.cchTextMax = sizeof(buf);
TreeView_GetItem(hTree, &tvi);
if (!strcmp(name, tvi.pszText))
return hChild;
hChild = TreeView_GetNextSibling(hTree, hChild);
}
return nil;
}
HTREEITEM plComponentDlg::IAddComponent(HWND hTree, plMaxNode *node)
{
plComponentBase *comp = node->ConvertToComponent();
// Try and find the component category in the tree
const char *category = comp->GetCategory();
HTREEITEM hCat = IFindTreeItem(hTree, category, TVI_ROOT);
// If it isn't there yet, add it
if (!hCat)
hCat = IAddLeaf(hTree, TVI_ROOT, category, 0);
// Try and find the component type in the tree
int idx = plComponentMgr::Inst().FindClassID(comp->ClassID());
HTREEITEM hType = ISearchTree(hTree, idx+1, hCat);
if (!hType)
{
// If it isn't there yet, add it
TSTR type;
comp->GetClassName(type);
if (IIsHidden(comp->ClassID()))
type.Append(" (Hidden)");
hType = IAddLeaf(hTree, hCat, type, idx+1);
}
// Add the name of this component to this type
return IAddLeaf(hTree, hType, node->GetName(), (LPARAM)node);
}
void plComponentDlg::IAddComponentsRecur(HWND hTree, plMaxNode *node)
{
if (node->IsComponent())
IAddComponent(hTree, node);
for (int i = 0; i < node->NumberOfChildren(); i++)
{
plMaxNode *child = (plMaxNode*)node->GetChildNode(i);
IAddComponentsRecur(hTree, child);
}
}
void plComponentDlg::ICreateMenu()
{
// Add a refresh option to the system menu, for those rare cases where the manager gets out of sync
HMENU hMenu = GetMenu(fhDlg);
HMENU hNew = CreatePopupMenu();
InsertMenu(hMenu, 0, MF_POPUP | MF_STRING | MF_BYPOSITION, (UINT)hNew, "New");
const char *lastCat = nil;
HMENU hCurType = nil;
UInt32 count = plComponentMgr::Inst().Count();
for (UInt32 i = 0; i < count; i++)
{
plComponentClassDesc *desc = (plComponentClassDesc*)plComponentMgr::Inst().Get(i);
// Don't put in the create menu if obsolete
if (desc->IsObsolete())
continue;
if (!lastCat || strcmp(lastCat, desc->Category()))
{
lastCat = desc->Category();
hCurType = CreatePopupMenu();
AppendMenu(hNew, MF_POPUP | MF_STRING, (UINT)hCurType, lastCat);
}
AppendMenu(hCurType, MF_STRING, MENU_ID_START+i, desc->ClassName());
}
}
// Taking advantage of the fact that the node pointers we store in the lParam
// will certainly be higher than the number of component types
bool plComponentDlg::IIsComponent(LPARAM lParam)
{
return (lParam > plComponentMgr::Inst().Count()+1);
}
bool plComponentDlg::IIsType(LPARAM lParam)
{
return (lParam > 0 && lParam <= plComponentMgr::Inst().Count()+1);
}
void plComponentDlg::IAttachTreeSelection()
{
HWND hTree = GetDlgItem(fhDlg, IDC_TREE);
// Get the current selection from the tree
HTREEITEM hSelected = TreeView_GetSelection(hTree);
TVITEM item;
item.mask = TVIF_PARAM;
item.hItem = hSelected;
TreeView_GetItem(hTree, &item);
// If the item has a lParam it is a component
if (IIsComponent(item.lParam))
{
plMaxNode *node = (plMaxNode*)item.lParam;
plComponentBase *comp = node->ConvertToComponent();
// Add each of the selected nodes that is not a component to the targets list
int count = fInterface->GetSelNodeCount();
for (int i = 0; i < count; i++)
{
plMaxNode *target = (plMaxNode*)fInterface->GetSelNode(i);
if (!target->IsComponent())
comp->AddTarget(target);
}
// Update the rollups to reflect the new component
if (plComponentUtil::Instance().IsOpen())
plComponentUtil::Instance().IUpdateRollups();
}
}
// Wow, this INodeTab class is very thorough
bool FindNodeInTab(INode *node, INodeTab& nodes)
{
for (int i = 0; i < nodes.Count(); i++)
{
if (node == nodes[i])
return true;
}
return false;
}
void plComponentDlg::SelectComponentTargs(INodeTab& nodes)
{
// Make an INode tab with all the targets in it
INodeTab targets;
for (int i = 0; i < nodes.Count(); i++)
{
plComponentBase *comp = ((plMaxNode*)nodes[i])->ConvertToComponent();
for (int j = 0; j < comp->NumTargets(); j++)
{
INode *node = comp->GetTarget(j);
if (node && !FindNodeInTab(node, targets))
targets.Append(1, &node);
}
}
// If the user is selecting a single component, make sure it is selected in the rollup too
if (plComponentUtil::Instance().IsOpen() && nodes.Count() == 1)
plComponentUtil::Instance().fLastComponent = ((plMaxNode*)nodes[0])->ConvertToComponent();
theHold.Begin();
fInterface->RedrawViews(fInterface->GetTime(), REDRAW_BEGIN);
fInterface->ClearNodeSelection(FALSE); // Deselect current nodes
// If there is at least one valid target, select it
if (targets.Count() > 0)
fInterface->SelectNodeTab(targets, TRUE, FALSE);
fInterface->RedrawViews(fInterface->GetTime(), REDRAW_END);
theHold.Accept("Select");
}
void plComponentDlg::ISelectTreeSelection()
{
INodeTab nodes;
INode *curComponent = (INode*)IGetTreeSelection();
if (curComponent)
{
nodes.Append(1, &curComponent);
}
else
{
HWND hTree = GetDlgItem(fhDlg, IDC_TREE);
HTREEITEM hRoot = TreeView_GetSelection(hTree);
IGetComponentsRecur(hTree, hRoot, nodes);
}
SelectComponentTargs(nodes);
}
void plComponentDlg::IGetComponentsRecur(HWND hTree, HTREEITEM hItem, INodeTab& nodes)
{
if (hItem)
{
INode *node = (INode*)ITreeItemToNode(hTree, hItem);
if (node)
nodes.Append(1, &node);
else
{
HTREEITEM hChild = TreeView_GetChild(hTree, hItem);
IGetComponentsRecur(hTree, hChild, nodes);
while (hChild = TreeView_GetNextSibling(hTree, hChild))
{
IGetComponentsRecur(hTree, hChild, nodes);
}
}
}
}
void plComponentDlg::IDeleteComponent(plMaxNode *component)
{
if (!component)
return;
// Make sure this components interface isn't showing
if (plComponentUtil::Instance().IsOpen())
plComponentUtil::Instance().IComponentPreDelete(component->ConvertToComponent());
// Delete the component from the scene
theHold.Begin();
fInterface->DeleteNode(component);
theHold.Accept(_T("Delete Component"));
// Delete the component from the tree
HWND hTree = GetDlgItem(fhDlg, IDC_TREE);
HTREEITEM hItem = TreeView_GetSelection(hTree);
HTREEITEM hParent = TreeView_GetParent(hTree, hItem);
TreeView_DeleteItem(hTree, hItem);
// If that was the only component of this type, delete the type too
if (!TreeView_GetChild(hTree, hParent))
{
HTREEITEM hCategory = TreeView_GetParent(hTree, hParent);
TreeView_DeleteItem(hTree, hParent);
// If this is the only type in this category, delete the category too!
// Sadly, this is the most we can delete.
if (!TreeView_GetChild(hTree, hCategory))
TreeView_DeleteItem(hTree, hCategory);
}
// Update the rollups in case the selected object had this component attached
if (plComponentUtil::Instance().IsOpen())
plComponentUtil::Instance().IUpdateRollups();
}
plMaxNode *plComponentDlg::IGetTreeSelection()
{
HWND hTree = GetDlgItem(fhDlg, IDC_TREE);
HTREEITEM hItem = TreeView_GetSelection(hTree);
return ITreeItemToNode(hTree, hItem);
}
plMaxNode *plComponentDlg::ITreeItemToNode(HWND hTree, HTREEITEM hItem)
{
if (hItem)
{
TVITEM item;
item.mask = TVIF_PARAM;
item.hItem = hItem;
TreeView_GetItem(hTree, &item);
if (IIsComponent(item.lParam))
return (plMaxNode*)item.lParam;
}
return nil;
}
enum
{
// Comp menu
kMenuDelete = 1,
kMenuRename,
kMenuCopy,
// Type menu
kMenuHide
};
void plComponentDlg::ICreateRightClickMenu()
{
fCompMenu = CreatePopupMenu();
AppendMenu(fCompMenu, MF_STRING, kMenuDelete, "Delete");
AppendMenu(fCompMenu, MF_STRING, kMenuRename, "Rename");
AppendMenu(fCompMenu, MF_STRING, kMenuCopy, "Copy");
fTypeMenu = CreatePopupMenu();
AppendMenu(fTypeMenu, MF_STRING, kMenuHide, "Hide/Show");
}
void plComponentDlg::IOpenRightClickMenu()
{
HWND hTree = GetDlgItem(fhDlg, IDC_TREE);
// Get the position of the cursor in screen and tree client coords
POINT point, localPoint;
GetCursorPos(&point);
localPoint = point;
ScreenToClient(hTree, &localPoint);
// Check if there is a tree item at that point
TVHITTESTINFO hitTest;
hitTest.pt = localPoint;
TreeView_HitTest(hTree, &hitTest);
if (!(hitTest.flags & TVHT_ONITEMLABEL))
return;
// Check if the tree item has an lParam (is a component)
TVITEM item;
item.mask = TVIF_PARAM;
item.hItem = hitTest.hItem;
TreeView_GetItem(hTree, &item);
HMENU menu = nil;
if (IIsComponent(item.lParam))
menu = fCompMenu;
else if (IIsType(item.lParam))
menu = fTypeMenu;
else
return;
// Select the item we're working with, so the user isn't confused
TreeView_SelectItem(hTree, item.hItem);
// Create the popup menu and get the option the user selects
SetForegroundWindow(fhDlg);
int sel = TrackPopupMenu(menu, TPM_NONOTIFY | TPM_RETURNCMD, point.x, point.y, 0, fhDlg, NULL);
switch(sel)
{
case kMenuDelete:
IDeleteComponent((plMaxNode*)item.lParam);
break;
case kMenuRename:
TreeView_EditLabel(hTree, hitTest.hItem);
break;
case kMenuCopy:
{
// Component to copy
INode *node = (INode*)item.lParam;
INodeTab tab;
tab.Append(1, &node);
// Copy
INodeTab copy;
// Make the copy
fInterface->CloneNodes(tab, Point3(0,0,0), true, NODE_COPY, NULL, &copy);
// Delete the targets for the copy and add it to the tree
plMaxNode *newNode = (plMaxNode*)copy[0];
newNode->ConvertToComponent()->DeleteAllTargets();
HTREEITEM hItem = IAddComponent(GetDlgItem(fhDlg, IDC_TREE), newNode);
TreeView_SelectItem(GetDlgItem(fhDlg, IDC_TREE), hItem);
}
break;
case kMenuHide:
{
ClassDesc *desc = plComponentMgr::Inst().Get(item.lParam-1);
std::vector<Class_ID>::iterator it;
it = std::find(fHiddenComps.begin(), fHiddenComps.end(), desc->ClassID());
TSTR name = desc->ClassName();
if (it == fHiddenComps.end())
{
fHiddenComps.push_back(desc->ClassID());
name.Append(" (Hidden)");
}
else
fHiddenComps.erase(it);
item.mask = TVIF_TEXT;
item.pszText = name;
TreeView_SetItem(GetDlgItem(fhDlg, IDC_TREE), &item);
plComponentUtil::Instance().IUpdateRollups();
}
break;
}
PostMessage(fhDlg, WM_USER, 0, 0);
}
HTREEITEM plComponentDlg::ISearchTree(HWND hTree, LPARAM lParam, HTREEITEM hCur)
{
// Get the param for the current item
TVITEM tvi;
tvi.mask = TVIF_PARAM;
tvi.hItem = hCur;
TreeView_GetItem(hTree, &tvi);
// If the lParam matches the one searching for, return the handle
if (tvi.lParam == lParam)
return hCur;
// Do a recursive search on the items children
HTREEITEM hChild = TreeView_GetChild(hTree, hCur);
while (hChild)
{
HTREEITEM hResult = ISearchTree(hTree, lParam, hChild);
if (hResult)
return hResult;
hChild = TreeView_GetNextSibling(hTree, hChild);
}
return NULL;
}
void plComponentDlg::IRefreshTree()
{
if (fhDlg)
{
fCommentNode = nil;
HWND hTree = GetDlgItem(fhDlg, IDC_TREE);
TreeView_DeleteAllItems(hTree);
IAddComponentsRecur(hTree, (plMaxNode*)GetCOREInterface()->GetRootNode());
}
}
void plComponentDlg::INotify(void *param, NotifyInfo *info)
{
if (info->intcode == NOTIFY_SYSTEM_SHUTDOWN)
{
UnRegisterNotification(INotify, 0, NOTIFY_FILE_PRE_OPEN);
UnRegisterNotification(INotify, 0, NOTIFY_SYSTEM_PRE_NEW);
UnRegisterNotification(INotify, 0, NOTIFY_SYSTEM_PRE_RESET);
UnRegisterNotification(INotify, 0, NOTIFY_FILE_PRE_MERGE);
UnRegisterNotification(INotify, 0, NOTIFY_PRE_IMPORT);
UnRegisterNotification(INotify, 0, NOTIFY_FILE_PRE_SAVE);
UnRegisterNotification(INotify, 0, NOTIFY_FILE_PRE_SAVE_OLD);
UnRegisterNotification(INotify, 0, NOTIFY_FILE_POST_OPEN);
UnRegisterNotification(INotify, 0, NOTIFY_SYSTEM_POST_NEW);
UnRegisterNotification(INotify, 0, NOTIFY_SYSTEM_POST_RESET);
UnRegisterNotification(INotify, 0, NOTIFY_FILE_POST_MERGE);
UnRegisterNotification(INotify, 0, NOTIFY_POST_IMPORT);
UnRegisterNotification(INotify, 0, NOTIFY_SYSTEM_SHUTDOWN);
}
// New nodes are coming in, refresh the scene component list
else if (info->intcode == NOTIFY_FILE_POST_OPEN ||
info->intcode == NOTIFY_SYSTEM_POST_NEW ||
info->intcode == NOTIFY_SYSTEM_POST_RESET ||
info->intcode == NOTIFY_FILE_POST_MERGE ||
info->intcode == NOTIFY_POST_IMPORT)
{
Instance().IRefreshTree();
}
// Nodes may be going away, save the comment now
else if (info->intcode == NOTIFY_FILE_PRE_OPEN ||
info->intcode == NOTIFY_SYSTEM_PRE_NEW ||
info->intcode == NOTIFY_SYSTEM_PRE_RESET ||
info->intcode == NOTIFY_FILE_PRE_MERGE ||
info->intcode == NOTIFY_PRE_IMPORT ||
info->intcode == NOTIFY_FILE_PRE_SAVE ||
info->intcode == NOTIFY_FILE_PRE_SAVE_OLD)
{
// This is causing a crash, so for now if you add a comment and don't
// pick another component or close the manager before closing the file,
// you lose the comment -Colin
// Instance().IGetComment();
}
}
void plComponentDlg::IUpdateNodeName(plMaxNode *node)
{
if (!fhDlg)
return;
// Update the name in the tree too
HWND hTree = GetDlgItem(fhDlg, IDC_TREE);
TVITEM tvi = {0};
tvi.hItem = ISearchTree(hTree, (LPARAM)node);
tvi.mask = TVIF_TEXT;
tvi.pszText = node->GetName();
TreeView_SetItem(hTree, &tvi);
}
void FindUnusedCompsRecur(plMaxNode *node, std::vector<plMaxNode*>& unused)
{
plComponentBase *comp = node->ConvertToComponent();
if (comp)
{
bool isAttached = false;
int num = comp->NumTargets();
for (int i = 0; i < num; i++)
{
if (comp->GetTarget(i))
{
isAttached = true;
break;
}
}
if (!isAttached)
unused.push_back(node);
}
for (int i = 0; i < node->NumberOfChildren(); i++)
FindUnusedCompsRecur((plMaxNode*)node->GetChildNode(i), unused);
}
void plComponentDlg::IRemoveUnusedComps()
{
std::vector<plMaxNode*> unused;
FindUnusedCompsRecur((plMaxNode*)GetCOREInterface()->GetRootNode(), unused);
for (int i = 0; i < unused.size(); i++)
GetCOREInterface()->DeleteNode(unused[i], FALSE);
IRefreshTree();
}
bool plComponentDlg::IIsHidden(Class_ID& cid)
{
return (std::find(fHiddenComps.begin(), fHiddenComps.end(), cid) != fHiddenComps.end());
}
////////////////////////////////////////////////////////////////////////////////
#include "hsUtils.h"
class plCopyCompCallback : public HitByNameDlgCallback
{
protected:
Tab<plComponentBase*> fSharedComps;
INodeTab fSelectedNodes;
public:
bool GetComponents()
{
fSelectedNodes.ZeroCount();
fSharedComps.ZeroCount();
Interface *ip = GetCOREInterface();
int nodeCount = ip->GetSelNodeCount();
if (nodeCount == 0)
return false;
// Get the components shared among the selected nodes
int i;
fSelectedNodes.SetCount(nodeCount);
for (i = 0; i < nodeCount; i++)
fSelectedNodes[i] = ip->GetSelNode(i);
INodeTab sharedComps;
if (plSharedComponents(fSelectedNodes, sharedComps) == 0)
return false;
// Put the shared components in a list
fSharedComps.SetCount(sharedComps.Count());
for (i = 0; i < sharedComps.Count(); i++)
fSharedComps[i] = ((plMaxNode*)sharedComps[i])->ConvertToComponent();
return true;
}
virtual TCHAR *dialogTitle() { return "Select Nodes"; }
virtual TCHAR *buttonText() { return "Copy"; }
virtual int filter(INode *node)
{
// Make sure this node doesn't already have the components
for (int i = 0; i < fSelectedNodes.Count(); i++)
{
if (fSelectedNodes[i] == node)
return FALSE;
}
return TRUE;
}
virtual void proc(INodeTab &nodeTab)
{
for (int i = 0; i < nodeTab.Count(); i++)
{
for (int j = 0; j < fSharedComps.Count(); j++)
{
fSharedComps[j]->AddTarget((plMaxNodeBase*)nodeTab[i]);
}
}
}
};
static plCopyCompCallback copyCompCallback;
void CopyComponents()
{
if (copyCompCallback.GetComponents())
GetCOREInterface()->DoHitByNameDialog(&copyCompCallback);
else
{
int count = GetCOREInterface()->GetSelNodeCount();
if (count == 0)
hsMessageBox("No object(s) selected", "Component Copy", hsMessageBoxNormal);
else if (count > 1)
hsMessageBox("No components are shared among the selected objects", "Component Copy", hsMessageBoxNormal);
else
hsMessageBox("No components on the selected object", "Component Copy", hsMessageBoxNormal);
}
}