mirror of
https://github.com/DrBeef/ioq3quest.git
synced 2024-11-29 07:11:44 +00:00
655 lines
17 KiB
C++
Executable file
655 lines
17 KiB
C++
Executable file
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code 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 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
Quake III Arena source code 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 Foobar; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
// GroupDlg.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "Radiant.h"
|
|
#include "GroupDlg.h"
|
|
#include "NameDlg.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#define IMG_PATCH 0
|
|
#define IMG_BRUSH 1
|
|
#define IMG_GROUP 2
|
|
#define IMG_ENTITY 3
|
|
#define IMG_ENTITYGROUP 4
|
|
#define IMG_MODEL 5
|
|
#define IMG_SCRIPT 6
|
|
|
|
// misc group support
|
|
#define MAX_GROUPS 4096
|
|
#define GROUP_DELIMETER '@'
|
|
#define GROUPNAME "QER_Group_%i"
|
|
|
|
CGroupDlg g_wndGroup;
|
|
CGroupDlg *g_pGroupDlg = &g_wndGroup;
|
|
|
|
// group_t are loaded / saved through "group_info" entities
|
|
// they hold epairs for group settings and additionnal access info (tree nodes)
|
|
group_t *g_pGroups = NULL;
|
|
|
|
void Group_Add(entity_t *e)
|
|
{
|
|
group_t *g = (group_t*)qmalloc(sizeof(group_t));
|
|
g->epairs = e->epairs;
|
|
g->next = NULL;
|
|
e->epairs = NULL;
|
|
// create a new group node
|
|
HTREEITEM hItem = g_wndGroup.m_wndTree.GetSelectedItem();
|
|
TVINSERTSTRUCT tvInsert;
|
|
memset(&tvInsert, 0, sizeof(TVINSERTSTRUCT));
|
|
tvInsert.item.iImage = IMG_GROUP;
|
|
tvInsert.item.iSelectedImage = tvInsert.item.iImage;
|
|
//++timo wasat?
|
|
// tvInsert.hParent = (hItem) ? hItem : m_hWorld;
|
|
tvInsert.hParent = g_wndGroup.m_hWorld;
|
|
tvInsert.hInsertAfter = NULL;
|
|
tvInsert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
|
|
char *pipo = ValueForKey(e->epairs, "group");
|
|
tvInsert.item.pszText = _T(ValueForKey(g->epairs, "group"));
|
|
g->itemOwner = g_wndGroup.m_wndTree.InsertItem(&tvInsert);
|
|
g->next = g_pGroups;
|
|
g_pGroups = g;
|
|
}
|
|
|
|
group_t* Group_Alloc(char *name)
|
|
{
|
|
group_t *g = (group_t*)qmalloc(sizeof(group_t));
|
|
SetKeyValue( g->epairs, "group", name );
|
|
return g;
|
|
}
|
|
|
|
group_t* Group_ForName(const char * name)
|
|
{
|
|
group_t *g = g_pGroups;
|
|
while (g != NULL)
|
|
{
|
|
if (strcmp( ValueForKey(g->epairs,"group"), name ) == 0)
|
|
break;
|
|
g = g->next;
|
|
}
|
|
return g;
|
|
}
|
|
|
|
void Group_AddToItem(brush_t *b, HTREEITEM item)
|
|
{
|
|
char cBuff[1024];
|
|
int nImage = IMG_BRUSH;
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
const char *pName = NULL;
|
|
const char *pNamed = Brush_GetKeyValue(b, "name");
|
|
|
|
if (!b->owner || (b->owner == world_entity))
|
|
{
|
|
if (b->patchBrush)
|
|
{
|
|
pName = "Generic Patch";
|
|
nImage = IMG_PATCH;
|
|
}
|
|
else
|
|
{
|
|
pName = "Generic Brush";
|
|
nImage = IMG_BRUSH;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pName = b->owner->eclass->name;
|
|
if (b->owner->eclass->fixedsize)
|
|
{
|
|
nImage = IMG_ENTITY;
|
|
}
|
|
else
|
|
{
|
|
nImage = IMG_ENTITYGROUP;
|
|
}
|
|
}
|
|
|
|
strcpy(cBuff, pName);
|
|
|
|
TVINSERTSTRUCT tvInsert;
|
|
memset(&tvInsert, 0, sizeof(TVINSERTSTRUCT));
|
|
tvInsert.item.iImage = (b->patchBrush) ? IMG_PATCH : IMG_BRUSH;
|
|
tvInsert.item.iSelectedImage = tvInsert.item.iImage;
|
|
tvInsert.hParent = item;
|
|
tvInsert.hInsertAfter = NULL;
|
|
tvInsert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
|
|
tvInsert.item.pszText = cBuff;
|
|
HTREEITEM itemNew = g_pGroupDlg->m_wndTree.InsertItem(&tvInsert);
|
|
g_pGroupDlg->m_wndTree.SetItemData(itemNew, reinterpret_cast<DWORD>(b));
|
|
b->itemOwner = itemNew;
|
|
g_pGroupDlg->m_wndTree.RedrawWindow();
|
|
|
|
}
|
|
|
|
void Group_RemoveBrush(brush_t *b)
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
if (b->itemOwner)
|
|
{
|
|
g_pGroupDlg->m_wndTree.DeleteItem(b->itemOwner);
|
|
b->itemOwner = NULL;
|
|
g_pGroupDlg->m_wndTree.RedrawWindow();
|
|
}
|
|
DeleteKey(b->epairs, "group");
|
|
}
|
|
|
|
void Group_AddToWorld(brush_t *b)
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
HTREEITEM itemParent = g_pGroupDlg->m_wndTree.GetRootItem();
|
|
Group_AddToItem(b, itemParent);
|
|
}
|
|
|
|
void Group_AddToProperGroup(brush_t *b)
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
// NOTE: we do a local copy of the "group" key because it gets erased by Group_RemoveBrush
|
|
const char *pGroup = Brush_GetKeyValue(b, "group");
|
|
// remove the entry in the tree if there's one
|
|
if (b->itemOwner)
|
|
{
|
|
g_pGroupDlg->m_wndTree.DeleteItem(b->itemOwner);
|
|
b->itemOwner = NULL;
|
|
g_pGroupDlg->m_wndTree.RedrawWindow();
|
|
}
|
|
|
|
if (*pGroup != 0)
|
|
{
|
|
// find the item
|
|
group_t *g = Group_ForName(pGroup);
|
|
if (g)
|
|
Group_AddToItem(b, g->itemOwner);
|
|
#ifdef _DEBUG
|
|
else
|
|
Sys_Printf("WARNING: unexpected Group_ForName not found in Group_AddToProperGroup\n");
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
Group_AddToWorld(b);
|
|
}
|
|
}
|
|
|
|
void Group_AddToSelected(brush_t *b)
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
HTREEITEM hItem = g_pGroupDlg->m_wndTree.GetSelectedItem();
|
|
if (hItem == NULL)
|
|
{
|
|
hItem = g_pGroupDlg->m_wndTree.GetRootItem();
|
|
}
|
|
Group_AddToItem(b, hItem);
|
|
}
|
|
|
|
void Group_Save(FILE *f)
|
|
{
|
|
group_t *g = g_pGroups;
|
|
while (g)
|
|
{
|
|
fprintf(f,"{\n\"classname\" \"group_info\"\n\"group\" \"%s\"\n}\n", ValueForKey( g->epairs, "group" ));
|
|
g = g->next;
|
|
}
|
|
}
|
|
|
|
void Group_Init()
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
// start by cleaning everything
|
|
// clean the groups
|
|
//++timo FIXME: we leak, delete the groups on the way (I don't have time to do it now)
|
|
#ifdef _DEBUG
|
|
Sys_Printf("TODO: fix leak in Group_Init\n");
|
|
#endif
|
|
group_t *g = g_pGroups;
|
|
while (g)
|
|
{
|
|
epair_t *ep,*enext;
|
|
for (ep = g->epairs ; ep ; ep=enext )
|
|
{
|
|
enext = ep->next;
|
|
free (ep->key);
|
|
free (ep->value);
|
|
free (ep);
|
|
}
|
|
g = g->next;
|
|
}
|
|
g_pGroups = NULL;
|
|
g_wndGroup.m_wndTree.DeleteAllItems();
|
|
TVINSERTSTRUCT tvInsert;
|
|
memset(&tvInsert, 0, sizeof(TVINSERTSTRUCT));
|
|
tvInsert.hParent = NULL;
|
|
tvInsert.hInsertAfter = NULL;
|
|
tvInsert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
|
|
tvInsert.item.pszText = _T("World");
|
|
tvInsert.item.iImage = IMG_GROUP;
|
|
tvInsert.item.iSelectedImage = IMG_GROUP;
|
|
HTREEITEM hWorld = g_wndGroup.m_wndTree.InsertItem(&tvInsert);
|
|
// walk through all the brushes, remove the itemOwner key and add them back where they belong
|
|
brush_t *b;
|
|
for (b = active_brushes.next; b != &active_brushes; b = b->next)
|
|
{
|
|
b->itemOwner = NULL;
|
|
Group_AddToProperGroup(b);
|
|
}
|
|
for (b = selected_brushes.next ; b != &selected_brushes ; b = b->next)
|
|
{
|
|
b->itemOwner = NULL;
|
|
Group_AddToProperGroup(b);
|
|
}
|
|
}
|
|
|
|
// scan through world_entity for groups in this map?
|
|
// we use GROUPNAME "QER_group_%i" to look for existing groups and their naming
|
|
//++timo FIXME: is this actually needed for anything?
|
|
void Group_GetListFromWorld(CStringArray *pArray)
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (world_entity == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
pArray->RemoveAll();
|
|
char cBuff[1024];
|
|
for (int i =0; i < MAX_GROUPS; i++)
|
|
{
|
|
sprintf(cBuff, GROUPNAME, i);
|
|
char *pGroup = ValueForKey(world_entity, cBuff);
|
|
if (pGroup && strlen(pGroup) > 0)
|
|
{
|
|
pArray->Add(pGroup);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Group_RemoveListFromWorld()
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
CStringArray array;
|
|
Group_GetListFromWorld(&array);
|
|
int nCount = array.GetSize();
|
|
for (int i = 0; i < nCount; i++)
|
|
{
|
|
DeleteKey(world_entity, array.GetAt(i));
|
|
}
|
|
}
|
|
|
|
/*
|
|
void Group_SetListToWorld(CStringArray *pArray)
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
char cBuff[1024];
|
|
Group_RemoveListFromWorld();
|
|
int nCount = pArray->GetSize();
|
|
for (int i = 0; i < nCount; i++)
|
|
{
|
|
sprintf(cBuff, GROUPNAME, i);
|
|
SetKeyValue(world_entity, cBuff, pArray->GetAt(i));
|
|
}
|
|
}
|
|
*/
|
|
|
|
int CountChar(const char *p, char c)
|
|
{
|
|
int nCount = 0;
|
|
int nLen = strlen(p)-1;
|
|
while (nLen-- >= 0)
|
|
{
|
|
if (p[nLen] == c)
|
|
{
|
|
nCount++;
|
|
}
|
|
}
|
|
return nCount;
|
|
}
|
|
|
|
/*
|
|
// this is not very efficient but should get the job done
|
|
// as our trees should never be too big
|
|
void Group_BuildTree(CTreeCtrl *pTree)
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
CStringArray array;
|
|
int i;
|
|
CString strTemp;
|
|
CString strRight;
|
|
|
|
//++timo WARNING: this is very dangerous! delete all tree items, without checking the brushes
|
|
pTree->DeleteAllItems();
|
|
TVINSERTSTRUCT tvInsert;
|
|
memset(&tvInsert, 0, sizeof(TVINSERTSTRUCT));
|
|
tvInsert.hParent = NULL;
|
|
tvInsert.hInsertAfter = NULL;
|
|
tvInsert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
|
|
tvInsert.item.pszText = _T("World");
|
|
tvInsert.item.iImage = IMG_GROUP;
|
|
tvInsert.item.iSelectedImage = IMG_GROUP;
|
|
HTREEITEM hWorld = pTree->InsertItem(&tvInsert);
|
|
|
|
Group_GetListFromWorld(&array);
|
|
|
|
// groups use @ to delimit levels, the number of @ signs
|
|
// start with ROOT item
|
|
// nothing is a peer with world, it is ancestor to everything
|
|
// expects things in order so first entry should be a 2nd level item
|
|
HTREEITEM itemParent = pTree->GetRootItem();
|
|
HTREEITEM itemLast = itemParent;
|
|
int nCount = array.GetSize();
|
|
int nLastLevel = 1;
|
|
for (i = 0; i < nCount; i++)
|
|
{
|
|
strTemp = array.GetAt(i);
|
|
int nLevel = CountChar(strTemp, GROUP_DELIMETER);
|
|
if (nLevel < nLastLevel)
|
|
{
|
|
int nLevelsUp = nLastLevel - nLevel;
|
|
while (nLevelsUp-- > 0)
|
|
{
|
|
itemParent = pTree->GetParentItem(itemParent);
|
|
}
|
|
}
|
|
else if (nLevel > nLastLevel)
|
|
{
|
|
itemParent = itemLast;
|
|
}
|
|
nLastLevel = nLevel;
|
|
char *pLast = strrchr(strTemp, GROUP_DELIMETER);
|
|
pLast++;
|
|
itemLast = pTree->InsertItem(pLast, itemParent);
|
|
}
|
|
}
|
|
*/
|
|
|
|
void DecomposeSiblingList(const char *p, CStringArray *pArray, CTreeCtrl *pTree, HTREEITEM itemChild)
|
|
{
|
|
CString str = p;
|
|
str += GROUP_DELIMETER;
|
|
while (itemChild)
|
|
{
|
|
CString strAdd = str;
|
|
strAdd += pTree->GetItemText(itemChild);
|
|
// do not want to add brushes or things, just groups
|
|
if (pTree->GetItemData(itemChild) == 0)
|
|
{
|
|
pArray->Add(strAdd);
|
|
}
|
|
if (pTree->ItemHasChildren(itemChild))
|
|
{
|
|
HTREEITEM itemOffspring = pTree->GetChildItem(itemChild);
|
|
DecomposeSiblingList(strAdd, pArray, pTree, itemOffspring);
|
|
}
|
|
itemChild = pTree->GetNextSiblingItem(itemChild);
|
|
}
|
|
}
|
|
|
|
/*
|
|
void Group_DecomposeTree(CTreeCtrl *pTree)
|
|
{
|
|
if (!g_qeglobals.m_bBrushPrimitMode)
|
|
{
|
|
return;
|
|
}
|
|
CStringArray array;
|
|
HTREEITEM itemParent = pTree->GetRootItem();
|
|
if (pTree->ItemHasChildren(itemParent))
|
|
{
|
|
HTREEITEM itemChild = pTree->GetChildItem(itemParent);
|
|
DecomposeSiblingList(pTree->GetItemText(itemParent), &array, pTree, itemChild);
|
|
}
|
|
Group_SetListToWorld(&array);
|
|
}
|
|
*/
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CGroupDlg dialog
|
|
|
|
|
|
CGroupDlg::CGroupDlg(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CGroupDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CGroupDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CGroupDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CGroupDlg)
|
|
DDX_Control(pDX, IDC_TREE_GROUP, m_wndTree);
|
|
DDX_Control(pDX, IDC_BTN_EDIT, m_wndEdit);
|
|
DDX_Control(pDX, IDC_BTN_DEL, m_wndDel);
|
|
DDX_Control(pDX, IDC_BTN_ADD, m_wndAdd);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CGroupDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CGroupDlg)
|
|
ON_WM_SIZE()
|
|
ON_BN_CLICKED(IDC_BTN_ADD, OnBtnAdd)
|
|
ON_BN_CLICKED(IDC_BTN_DEL, OnBtnDel)
|
|
ON_BN_CLICKED(IDC_BTN_EDIT, OnBtnEdit)
|
|
ON_NOTIFY(NM_RCLICK, IDC_TREE_GROUP, OnRclickTreeGroup)
|
|
ON_NOTIFY(TVN_ENDLABELEDIT, IDC_TREE_GROUP, OnEndlabeleditTreeGroup)
|
|
ON_NOTIFY(NM_CLICK, IDC_TREE_GROUP, OnClickTreeGroup)
|
|
ON_NOTIFY(TVN_SETDISPINFO, IDC_TREE_GROUP, OnSetdispinfoTreeGroup)
|
|
ON_NOTIFY(TVN_BEGINDRAG, IDC_TREE_GROUP, OnBegindragTreeGroup)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CGroupDlg message handlers
|
|
|
|
void CGroupDlg::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
CDialog::OnSize(nType, cx, cy);
|
|
CRect rct;
|
|
GetClientRect(rct);
|
|
|
|
if ( m_wndAdd.GetSafeHwnd())
|
|
{
|
|
//all borders at 4, spacing at 6
|
|
CRect rctButton;
|
|
m_wndAdd.GetWindowRect(rctButton);
|
|
int nWidth = rctButton.Width();
|
|
int nHeight = rctButton.Height();
|
|
|
|
int nTop = rct.Height() - nHeight - 4;
|
|
|
|
m_wndAdd.SetWindowPos(NULL, 4, nTop, 0, 0, SWP_NOSIZE);
|
|
m_wndEdit.SetWindowPos(NULL, 8 + nWidth , nTop, 0, 0, SWP_NOSIZE);
|
|
m_wndDel.SetWindowPos(NULL, 12 + (nWidth * 2), nTop, 0, 0, SWP_NOSIZE);
|
|
rct.bottom = nTop;
|
|
m_wndTree.SetWindowPos(NULL, rct.left + 4, rct.top + 4, rct.Width() - 8, rct.Height() - 8, SWP_SHOWWINDOW);
|
|
}
|
|
}
|
|
|
|
BOOL CGroupDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
m_imgList.Create(IDB_BITMAP_GROUPS, 16, 0, ILC_COLOR);
|
|
m_wndTree.SetImageList(&m_imgList, TVSIL_NORMAL);
|
|
InitGroups();
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CGroupDlg::InitGroups()
|
|
{
|
|
Group_Init();
|
|
}
|
|
|
|
// add a new group, put all selected brushes into the group
|
|
void CGroupDlg::OnBtnAdd()
|
|
{
|
|
CNameDlg dlg("New Group", this);
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
// create a new group node
|
|
HTREEITEM hItem = m_wndTree.GetSelectedItem();
|
|
TVINSERTSTRUCT tvInsert;
|
|
memset(&tvInsert, 0, sizeof(TVINSERTSTRUCT));
|
|
tvInsert.item.iImage = IMG_GROUP;
|
|
tvInsert.item.iSelectedImage = tvInsert.item.iImage;
|
|
//++timo wasat?
|
|
// tvInsert.hParent = (hItem) ? hItem : m_hWorld;
|
|
tvInsert.hParent = m_hWorld;
|
|
tvInsert.hInsertAfter = NULL;
|
|
tvInsert.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
|
|
tvInsert.item.pszText = _T(dlg.m_strName.GetBuffer(0));
|
|
// create a new group
|
|
group_t *g = Group_Alloc( dlg.m_strName.GetBuffer(0) );
|
|
g->itemOwner = m_wndTree.InsertItem(&tvInsert);
|
|
g->next = g_pGroups;
|
|
g_pGroups = g;
|
|
// now add the selected brushes
|
|
// NOTE: it would be much faster to give the group_t for adding
|
|
// but Select_AddToGroup is the standard way for all other cases
|
|
Select_AddToGroup( dlg.m_strName.GetBuffer(0) );
|
|
}
|
|
}
|
|
|
|
void CGroupDlg::OnBtnDel()
|
|
{
|
|
}
|
|
|
|
void CGroupDlg::OnBtnEdit()
|
|
{
|
|
}
|
|
|
|
BOOL CGroupDlg::OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pLResult)
|
|
{
|
|
return CDialog::OnChildNotify(message, wParam, lParam, pLResult);
|
|
}
|
|
|
|
BOOL CGroupDlg::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
|
|
{
|
|
return CDialog::OnNotify(wParam, lParam, pResult);
|
|
}
|
|
|
|
void CGroupDlg::OnRclickTreeGroup(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CGroupDlg::OnEndlabeleditTreeGroup(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
TV_DISPINFO* pTVDispInfo = (TV_DISPINFO*)pNMHDR;
|
|
const char *pText = pTVDispInfo->item.pszText;
|
|
if (pText && strlen(pText) > 0)
|
|
{
|
|
HTREEITEM item = pTVDispInfo->item.hItem;
|
|
if (m_wndTree.GetRootItem() != item)
|
|
{
|
|
m_wndTree.SetItemText(item, pText);
|
|
if (pTVDispInfo->item.iImage != IMG_GROUP)
|
|
{
|
|
// if it is an entity
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Sys_Printf("Cannot rename the world\n");
|
|
}
|
|
}
|
|
m_wndTree.RedrawWindow();
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CGroupDlg::OnClickTreeGroup(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CGroupDlg::OnSetdispinfoTreeGroup(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
TV_DISPINFO* pTVDispInfo = (TV_DISPINFO*)pNMHDR;
|
|
// TODO: Add your control notification handler code here
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CGroupDlg::OnCancel()
|
|
{
|
|
TreeView_EndEditLabelNow(m_wndTree.GetSafeHwnd(), TRUE);
|
|
}
|
|
|
|
void CGroupDlg::OnOK()
|
|
{
|
|
TreeView_EndEditLabelNow(m_wndTree.GetSafeHwnd(), FALSE);
|
|
}
|
|
|
|
void CGroupDlg::OnBegindragTreeGroup(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
|
|
// TODO: Add your control notification handler code here
|
|
|
|
*pResult = 0;
|
|
}
|