Quake-III-Arena

GroupDlg.cpp (16420B)

---

 /*
 ===========================================================================
 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;
 }