sourceforge-mirrors
/
q3cellshading
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
q3cellshading/q3radiant/GroupDlg.cpp

656 lines
17 KiB
C++
Raw Blame History

/*
===========================================================================
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;
}
Reference in New Issue View Git Blame Copy Permalink