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.
4830 lines
131 KiB
4830 lines
131 KiB
5 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
|
//
|
||
|
|
// Purpose:
|
||
|
|
//
|
||
|
|
//=============================================================================
|
||
|
|
|
||
|
|
#include "stdafx.h"
|
||
|
|
#include "hammer.h"
|
||
|
|
#include "EntityHelpDlg.h"
|
||
|
|
#include "History.h"
|
||
|
|
#include "MainFrm.h"
|
||
|
|
#include "MapWorld.h"
|
||
|
|
#include "OP_Entity.h"
|
||
|
|
#include "CustomMessages.h"
|
||
|
|
#include "NewKeyValue.h"
|
||
|
|
#include "GlobalFunctions.h"
|
||
|
|
#include "MapDoc.h"
|
||
|
|
#include "MapEntity.h"
|
||
|
|
#include "ObjectProperties.h"
|
||
|
|
#include "TargetNameCombo.h"
|
||
|
|
#include "TextureBrowser.h"
|
||
|
|
#include "TextureSystem.h"
|
||
|
|
#include "ToolPickAngles.h"
|
||
|
|
#include "ToolPickEntity.h"
|
||
|
|
#include "ToolPickFace.h"
|
||
|
|
#include "ToolManager.h"
|
||
|
|
#include "SoundBrowser.h"
|
||
|
|
#include "ifilesystemopendialog.h"
|
||
|
|
#include "filesystem_tools.h"
|
||
|
|
#include "tier0/icommandline.h"
|
||
|
|
#include "HammerVGui.h"
|
||
|
|
#include "mapview3d.h"
|
||
|
|
#include "camera.h"
|
||
|
|
#include "Selection.h"
|
||
|
|
#include "options.h"
|
||
|
|
#include "op_flags.h"
|
||
|
|
#include "MapInstance.h"
|
||
|
|
|
||
|
|
extern GameData *pGD; // current game data
|
||
|
|
|
||
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
|
#include <tier0/memdbgon.h>
|
||
|
|
|
||
|
|
|
||
|
|
#pragma warning( disable : 4355 )
|
||
|
|
|
||
|
|
|
||
|
|
#define IDC_SMARTCONTROL 1
|
||
|
|
#define IDC_SMARTCONTROL_TARGETNAME 2 // We have a different define for this because we rely 100%
|
||
|
|
// on CTargetNameComboBox for the info about its updates.
|
||
|
|
#define IDC_SMARTCONTROL_INSTANCE_VARIABLE 3
|
||
|
|
#define IDC_SMARTCONTROL_INSTANCE_VALUE 4
|
||
|
|
#define IDC_SMARTCONTROL_INSTANCE_PARM 5
|
||
|
|
|
||
|
|
#define SPAWNFLAGS_KEYNAME "spawnflags"
|
||
|
|
|
||
|
|
#define INSTANCE_VAR_MAP_START -10
|
||
|
|
|
||
|
|
|
||
|
|
static WCKeyValues kvClipboard;
|
||
|
|
static BOOL bKvClipEmpty = TRUE;
|
||
|
|
|
||
|
|
// Colors used for the keyvalues list control.
|
||
|
|
static COLORREF g_BgColor_Edited = RGB( 239, 239, 255 ); // blue
|
||
|
|
static COLORREF g_BgColor_Default = RGB( 255, 255, 255 ); // white
|
||
|
|
static COLORREF g_BgColor_Added = RGB( 255, 239, 239 ); // pink
|
||
|
|
static COLORREF g_BgColor_InstanceParm = RGB( 239, 255, 239 ); // green
|
||
|
|
static COLORREF g_TextColor_Normal = RGB( 0, 0, 0 );
|
||
|
|
static COLORREF g_TextColor_MissingTarget = RGB( 255, 0, 0 ); // dark red
|
||
|
|
|
||
|
|
static int g_DumbEditControls[] = {IDC_DELETEKEYVALUE, IDC_KEY, IDC_VALUE, IDC_ADDKEYVALUE, IDC_KEY_LABEL, IDC_VALUE_LABEL};
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Less function for use with CString
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CStringLessFunc(const CString &lhs, const CString &rhs)
|
||
|
|
{
|
||
|
|
return (Q_strcmp(lhs, rhs) < 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Returns true if the string specifies the name of an entity in the world.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
static bool IsValidTargetName( const char *pTestName )
|
||
|
|
{
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
CMapWorld *pWorld = pDoc->GetMapWorld();
|
||
|
|
const CMapEntityList *pList = pWorld->EntityList_GetList();
|
||
|
|
|
||
|
|
for ( int i=0; i < pList->Count(); i++ )
|
||
|
|
{
|
||
|
|
CMapEntity *pEntity = pList->Element( i );
|
||
|
|
const char *pszTargetName = pEntity->GetKeyValue("targetname");
|
||
|
|
if ( pszTargetName && Q_stricmp( pszTargetName, pTestName ) == 0 )
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
static CString StripDirPrefix( const char *pFilename, const char *pPrefix )
|
||
|
|
{
|
||
|
|
int prefixLen = V_strlen( pPrefix );
|
||
|
|
if ( V_stristr( pFilename, pPrefix ) == pFilename )
|
||
|
|
{
|
||
|
|
if ( pFilename[prefixLen] == '/' || pFilename[prefixLen] == '\\' )
|
||
|
|
return pFilename + prefixLen + 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return pFilename;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// CColoredListCtrl implementation.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
CColoredListCtrl::CColoredListCtrl( IItemColorCallback *pCallback )
|
||
|
|
{
|
||
|
|
m_pCallback = pCallback;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void CColoredListCtrl::DrawItem( LPDRAWITEMSTRUCT p )
|
||
|
|
{
|
||
|
|
CDC *pDC = CDC::FromHandle( p->hDC );
|
||
|
|
|
||
|
|
COLORREF bgColor, txtColor;
|
||
|
|
m_pCallback->GetItemColor( p->itemID, &bgColor, &txtColor );
|
||
|
|
|
||
|
|
// Draw the background.
|
||
|
|
CBrush br;
|
||
|
|
CPen pen( PS_SOLID, 0, bgColor );
|
||
|
|
|
||
|
|
// Selected? Draw a dotted border.
|
||
|
|
LOGBRUSH logBrush;
|
||
|
|
logBrush.lbColor = RGB(0,0,0);
|
||
|
|
logBrush.lbHatch = HS_CROSS;
|
||
|
|
logBrush.lbStyle = BS_SOLID;
|
||
|
|
CPen dashedPen( PS_ALTERNATE, 1, &logBrush );
|
||
|
|
|
||
|
|
if ( p->itemState & ODS_SELECTED )
|
||
|
|
pDC->SelectObject( &dashedPen );
|
||
|
|
else
|
||
|
|
pDC->SelectObject( &pen );
|
||
|
|
|
||
|
|
br.CreateSolidBrush( bgColor );
|
||
|
|
pDC->SelectObject( &br );
|
||
|
|
RECT rcFill = p->rcItem;
|
||
|
|
rcFill.bottom -= 1;
|
||
|
|
pDC->Rectangle( &rcFill );
|
||
|
|
|
||
|
|
// Setup for drawing text.
|
||
|
|
pDC->SetTextColor( txtColor );
|
||
|
|
|
||
|
|
// Draw the first column.
|
||
|
|
RECT rcItem = p->rcItem;
|
||
|
|
rcItem.left += 3;
|
||
|
|
pDC->DrawText( GetItemText( p->itemID, 0 ), &rcItem, DT_LEFT | DT_VCENTER );
|
||
|
|
|
||
|
|
// Draw the second column.
|
||
|
|
LVCOLUMN columnInfo;
|
||
|
|
columnInfo.mask = LVCF_WIDTH;
|
||
|
|
GetColumn( 0, &columnInfo );
|
||
|
|
rcItem = p->rcItem;
|
||
|
|
rcItem.left += columnInfo.cx;
|
||
|
|
|
||
|
|
// Give our owner a chance to draw the second column.
|
||
|
|
if ( !m_pCallback->CustomDrawItemValue( p, &rcItem ) )
|
||
|
|
{
|
||
|
|
rcItem.left += 3;
|
||
|
|
pDC->DrawText( GetItemText( p->itemID, 1 ), &rcItem, DT_LEFT | DT_VCENTER );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
class CMyEdit : public CEdit
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
void SetParentPage(COP_Entity* pPage)
|
||
|
|
{
|
||
|
|
m_pParent = pPage;
|
||
|
|
}
|
||
|
|
|
||
|
|
afx_msg void OnChar(UINT, UINT, UINT);
|
||
|
|
|
||
|
|
COP_Entity *m_pParent;
|
||
|
|
DECLARE_MESSAGE_MAP()
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
BEGIN_MESSAGE_MAP(CMyEdit, CEdit)
|
||
|
|
ON_WM_CHAR()
|
||
|
|
END_MESSAGE_MAP()
|
||
|
|
|
||
|
|
|
||
|
|
class CMyComboBox : public CComboBox
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
void SetParentPage(COP_Entity* pPage)
|
||
|
|
{
|
||
|
|
m_pParent = pPage;
|
||
|
|
}
|
||
|
|
|
||
|
|
afx_msg void OnChar(UINT, UINT, UINT);
|
||
|
|
|
||
|
|
COP_Entity *m_pParent;
|
||
|
|
DECLARE_MESSAGE_MAP()
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
BEGIN_MESSAGE_MAP(CMyComboBox, CComboBox)
|
||
|
|
ON_WM_CHAR()
|
||
|
|
END_MESSAGE_MAP()
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Called by the angles picker tool when a target point is picked. This
|
||
|
|
// stuffs the angles into the smartedit control so that the entity
|
||
|
|
// points at the target position.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPickAnglesTarget::OnNotifyPickAngles(const Vector &vecPos)
|
||
|
|
{
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
if (!pDoc)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
GetHistory()->MarkUndoPosition(pDoc->GetSelection()->GetList(), "Point At");
|
||
|
|
|
||
|
|
//
|
||
|
|
// Update the edit control text with the entity name. This text will be
|
||
|
|
// stuffed into the local keyvalue storage in OnChangeSmartControl.
|
||
|
|
//
|
||
|
|
FOR_EACH_OBJ( *m_pDlg->m_pObjectList, pos )
|
||
|
|
{
|
||
|
|
CMapClass *pObject = m_pDlg->m_pObjectList->Element(pos);
|
||
|
|
CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pObject);
|
||
|
|
Assert(pEntity != NULL);
|
||
|
|
if (pEntity != NULL)
|
||
|
|
{
|
||
|
|
GetHistory()->Keep(pEntity);
|
||
|
|
|
||
|
|
// Calculate the angles to point this entity at the chosen spot.
|
||
|
|
Vector vecOrigin;
|
||
|
|
pEntity->GetOrigin(vecOrigin);
|
||
|
|
Vector vecForward = vecPos - vecOrigin;
|
||
|
|
|
||
|
|
QAngle angFace;
|
||
|
|
VectorAngles(vecForward, angFace);
|
||
|
|
|
||
|
|
// HACK: lights negate pitch
|
||
|
|
if (pEntity->GetClassName() && (!strnicmp(pEntity->GetClassName(), "light_", 6)))
|
||
|
|
{
|
||
|
|
angFace[PITCH] *= -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update the edit control with the calculated angles.
|
||
|
|
char szAngles[80];
|
||
|
|
sprintf(szAngles, "%.0f %.0f %.0f", angFace[PITCH], angFace[YAW], angFace[ROLL]);
|
||
|
|
pEntity->SetKeyValue("angles", szAngles);
|
||
|
|
|
||
|
|
// HACK: lights have a separate "pitch" key
|
||
|
|
if (pEntity->GetClassName() && (!strnicmp(pEntity->GetClassName(), "light_", 6)))
|
||
|
|
{
|
||
|
|
char szPitch[20];
|
||
|
|
sprintf(szPitch, "%.0f", angFace[PITCH]);
|
||
|
|
pEntity->SetKeyValue("pitch", szPitch);
|
||
|
|
}
|
||
|
|
|
||
|
|
// FIXME: this should be called automatically, but it isn't
|
||
|
|
m_pDlg->OnChangeSmartcontrol();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
m_pDlg->StopPicking();
|
||
|
|
|
||
|
|
GetMainWnd()->pObjectProperties->MarkDataDirty();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Called by the entity picker tool when an entity is picked. This
|
||
|
|
// stuffs the entity name into the smartedit control.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPickEntityTarget::OnNotifyPickEntity(CToolPickEntity *pTool)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Update the edit control text with the entity name. This text will be
|
||
|
|
// stuffed into the local keyvalue storage in OnChangeSmartControl.
|
||
|
|
//
|
||
|
|
CMapEntityList Full;
|
||
|
|
CMapEntityList Partial;
|
||
|
|
pTool->GetSelectedEntities(Full, Partial);
|
||
|
|
CMapEntity *pEntity = Full.Element(0);
|
||
|
|
if (pEntity)
|
||
|
|
{
|
||
|
|
const char *pszValue = pEntity->GetKeyValue(m_szKey);
|
||
|
|
if (!pszValue)
|
||
|
|
{
|
||
|
|
pszValue = "";
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pDlg->SetSmartControlText(pszValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pDlg->StopPicking();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Called by the face picker tool when the face selection changes.
|
||
|
|
// Input : pTool - The face picker tool that is notifying us.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPickFaceTarget::OnNotifyPickFace(CToolPickFace *pTool)
|
||
|
|
{
|
||
|
|
m_pDlg->UpdatePickFaceText(pTool);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
CSmartControlTargetNameRouter::CSmartControlTargetNameRouter( COP_Entity *pDlg )
|
||
|
|
{
|
||
|
|
m_pDlg = pDlg;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CSmartControlTargetNameRouter::OnTextChanged( const char *pText )
|
||
|
|
{
|
||
|
|
m_pDlg->OnSmartControlTargetNameChanged( pText );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
BEGIN_MESSAGE_MAP(COP_Entity, CObjectPage)
|
||
|
|
//{{AFX_MSG_MAP(COP_Entity)
|
||
|
|
ON_NOTIFY(LVN_ITEMCHANGED, IDC_KEYVALUES, OnItemChangedKeyValues)
|
||
|
|
ON_NOTIFY(NM_DBLCLK, IDC_KEYVALUES, OnDblClickKeyValues)
|
||
|
|
|
||
|
|
ON_BN_CLICKED(IDC_ADDKEYVALUE, OnAddkeyvalue)
|
||
|
|
ON_BN_CLICKED(IDC_REMOVEKEYVALUE, OnRemovekeyvalue)
|
||
|
|
ON_BN_CLICKED(IDC_SMARTEDIT, OnSmartedit)
|
||
|
|
ON_EN_CHANGE(IDC_VALUE, OnChangeKeyorValue)
|
||
|
|
ON_BN_CLICKED(IDC_COPY, OnCopy)
|
||
|
|
ON_BN_CLICKED(IDC_PASTE, OnPaste)
|
||
|
|
ON_BN_CLICKED(IDC_PICKCOLOR, OnPickColor)
|
||
|
|
ON_WM_SIZE()
|
||
|
|
ON_EN_SETFOCUS(IDC_KEY, OnSetfocusKey)
|
||
|
|
ON_EN_KILLFOCUS(IDC_KEY, OnKillfocusKey)
|
||
|
|
ON_MESSAGE(ABN_CHANGED, OnChangeAngleBox)
|
||
|
|
ON_CBN_SELCHANGE(IDC_SMARTCONTROL, OnChangeSmartcontrolSel)
|
||
|
|
ON_CBN_EDITUPDATE(IDC_SMARTCONTROL, OnChangeSmartcontrol)
|
||
|
|
ON_EN_CHANGE(IDC_SMARTCONTROL, OnChangeSmartcontrol)
|
||
|
|
ON_BN_CLICKED(IDC_BROWSE, OnBrowse)
|
||
|
|
ON_BN_CLICKED(IDC_BROWSE_INSTANCE, OnBrowseInstance)
|
||
|
|
ON_BN_CLICKED(IDC_PLAY_SOUND, OnPlaySound)
|
||
|
|
ON_BN_CLICKED(IDC_MARK, OnMark)
|
||
|
|
ON_BN_CLICKED(IDC_MARK_AND_ADD, OnMarkAndAdd)
|
||
|
|
ON_BN_CLICKED(IDC_PICK_FACES, OnPickFaces)
|
||
|
|
ON_BN_CLICKED(IDC_ENTITY_HELP, OnEntityHelp)
|
||
|
|
ON_BN_CLICKED(IDC_PICK_ANGLES, OnPickAngles)
|
||
|
|
ON_BN_CLICKED(IDC_PICK_ENTITY, OnPickEntity)
|
||
|
|
ON_BN_CLICKED(IDC_CAMERA_DISTANCE, OnCameraDistance)
|
||
|
|
ON_EN_CHANGE(IDC_SMARTCONTROL_INSTANCE_VARIABLE, OnChangeInstanceVariableControl)
|
||
|
|
ON_EN_CHANGE(IDC_SMARTCONTROL_INSTANCE_VALUE, OnChangeInstanceVariableControl)
|
||
|
|
ON_EN_CHANGE(IDC_SMARTCONTROL_INSTANCE_PARM, OnChangeInstanceParmControl)
|
||
|
|
ON_CBN_SELCHANGE(IDC_SMARTCONTROL_INSTANCE_PARM, OnChangeInstanceParmControl)
|
||
|
|
ON_CBN_EDITUPDATE(IDC_SMARTCONTROL_INSTANCE_PARM, OnChangeInstanceParmControl)
|
||
|
|
//}}AFX_MSG_MAP
|
||
|
|
END_MESSAGE_MAP()
|
||
|
|
|
||
|
|
|
||
|
|
IMPLEMENT_DYNCREATE(COP_Entity, CObjectPage)
|
||
|
|
|
||
|
|
|
||
|
|
typedef int (CALLBACK *ColumnSortFn)( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam );
|
||
|
|
|
||
|
|
int InternalSortByColumn( COP_Entity *pDlg, const char *pShortName1, const char *pShortName2, int iColumn )
|
||
|
|
{
|
||
|
|
int i1 = pDlg->GetKeyValueRowByShortName( pShortName1 );
|
||
|
|
int i2 = pDlg->GetKeyValueRowByShortName( pShortName2 );
|
||
|
|
if ( i1 == -1 || i2 == -1 )
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
CString str1 = pDlg->m_VarList.GetItemText( i1, iColumn );
|
||
|
|
CString str2 = pDlg->m_VarList.GetItemText( i2, iColumn );
|
||
|
|
|
||
|
|
return Q_stricmp( str1, str2 );
|
||
|
|
}
|
||
|
|
|
||
|
|
int CALLBACK SortByItemEditedState( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam )
|
||
|
|
{
|
||
|
|
COP_Entity *pDlg = (COP_Entity*)lpParam;
|
||
|
|
if ( !pDlg->m_pDisplayClass )
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
const char *pShortName1 = (const char*)iItem1;
|
||
|
|
const char *pShortName2 = (const char*)iItem2;
|
||
|
|
|
||
|
|
EKeyState s1, s2;
|
||
|
|
bool b1, b2;
|
||
|
|
pDlg->GetKeyState( pShortName1, &s1, &b1 );
|
||
|
|
pDlg->GetKeyState( pShortName2, &s2, &b2 );
|
||
|
|
|
||
|
|
bool bNew1 = (s1 == k_EKeyState_AddedManually);
|
||
|
|
bool bNew2 = (s2 == k_EKeyState_AddedManually);
|
||
|
|
|
||
|
|
return bNew1 < bNew2;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int CALLBACK SortByColumn0( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam )
|
||
|
|
{
|
||
|
|
return InternalSortByColumn( (COP_Entity*)lpParam, (const char*)iItem1, (const char*)iItem2, 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
static int CALLBACK SortByColumn1( LPARAM iItem1, LPARAM iItem2, LPARAM lpParam )
|
||
|
|
{
|
||
|
|
return InternalSortByColumn( (COP_Entity*)lpParam, (const char*)iItem1, (const char*)iItem2, 1 );
|
||
|
|
}
|
||
|
|
|
||
|
|
ColumnSortFn g_ColumnSortFunctions[] =
|
||
|
|
{
|
||
|
|
SortByItemEditedState,
|
||
|
|
SortByColumn0,
|
||
|
|
SortByColumn1
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
COP_Entity::COP_Entity()
|
||
|
|
: CObjectPage(COP_Entity::IDD),
|
||
|
|
m_cClasses( this ),
|
||
|
|
m_SmartControlTargetNameRouter( this ),
|
||
|
|
m_VarList( this ),
|
||
|
|
m_InstanceParmData( CStringLessFunc )
|
||
|
|
{
|
||
|
|
//{{AFX_DATA_INIT(COP_Entity)
|
||
|
|
// NOTE: the ClassWizard will add member initialization here
|
||
|
|
//}}AFX_DATA_INIT
|
||
|
|
|
||
|
|
m_iLastClassListSolidClasses = -9999;
|
||
|
|
m_bAllowPresentProperties = true;
|
||
|
|
m_nPresentPropertiesCalls = 0;
|
||
|
|
m_bClassSelectionEmpty = false;
|
||
|
|
m_cClasses.SetOnlyProvideSuggestions( true );
|
||
|
|
|
||
|
|
m_bPicking = false;
|
||
|
|
m_bChangingKeyName = false;
|
||
|
|
|
||
|
|
m_pSmartBrowseButton = NULL;
|
||
|
|
m_pLastSmartControlVar = NULL;
|
||
|
|
|
||
|
|
m_pEditInstanceVariable = NULL;
|
||
|
|
m_pEditInstanceValue = NULL;
|
||
|
|
m_pComboInstanceParmType = NULL;
|
||
|
|
|
||
|
|
m_bIgnoreKVChange = false;
|
||
|
|
m_bSmartedit = true;
|
||
|
|
m_pSmartControl = NULL;
|
||
|
|
m_pDisplayClass = NULL;
|
||
|
|
m_pEditClass = NULL;
|
||
|
|
m_eEditType = ivString;
|
||
|
|
|
||
|
|
m_nNewKeyCount = 0;
|
||
|
|
m_iSortColumn = -1;
|
||
|
|
|
||
|
|
m_bEnableControlUpdate = true;
|
||
|
|
|
||
|
|
m_pEditObjectRuntimeClass = RUNTIME_CLASS(editCEditGameClass);
|
||
|
|
|
||
|
|
pModelBrowser = NULL;
|
||
|
|
m_pInstanceVar = NULL;
|
||
|
|
|
||
|
|
m_bCustomColorsLoaded = false; //Make sure they get loaded!
|
||
|
|
memset(CustomColors, 0, sizeof(CustomColors));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Destructor.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
COP_Entity::~COP_Entity(void)
|
||
|
|
{
|
||
|
|
DestroySmartControls();
|
||
|
|
|
||
|
|
delete pModelBrowser;
|
||
|
|
pModelBrowser = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pDX -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::DoDataExchange(CDataExchange* pDX)
|
||
|
|
{
|
||
|
|
CObjectPage::DoDataExchange(pDX);
|
||
|
|
//{{AFX_DATA_MAP(COP_Entity)
|
||
|
|
DDX_Control(pDX, IDC_VALUE, m_cValue);
|
||
|
|
DDX_Control(pDX, IDC_KEYVALUES, m_VarList);
|
||
|
|
DDX_Control(pDX, IDC_KEY, m_cKey);
|
||
|
|
DDX_Control(pDX, IDC_ENTITY_COMMENTS, m_Comments);
|
||
|
|
DDX_Control(pDX, IDC_KEYVALUE_HELP, m_KeyValueHelpText);
|
||
|
|
DDX_Control(pDX, IDC_PASTE, m_PasteControl);
|
||
|
|
//}}AFX_DATA_MAP
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Handles notifications..
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
BOOL COP_Entity::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
|
||
|
|
{
|
||
|
|
NMHDR *pHdr = (NMHDR*)lParam;
|
||
|
|
if ( pHdr->idFrom == IDC_KEYVALUES )
|
||
|
|
{
|
||
|
|
if ( pHdr->code == LVN_COLUMNCLICK )
|
||
|
|
{
|
||
|
|
LPNMLISTVIEW pListView = (LPNMLISTVIEW)lParam;
|
||
|
|
|
||
|
|
// Now sort by this column.
|
||
|
|
m_iSortColumn = max( 0, min( pListView->iSubItem, ARRAYSIZE( g_ColumnSortFunctions ) - 1 ) );
|
||
|
|
ResortItems();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return CObjectPage::OnNotify(wParam, lParam, pResult);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Determine how/if this key's value has been modified relative
|
||
|
|
// to its default in the FGD file.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::GetKeyState( const char *pShortName, EKeyState *pState, bool *pMissingTarget )
|
||
|
|
{
|
||
|
|
*pMissingTarget = false;
|
||
|
|
|
||
|
|
// If we're in multiedit mode with various types of entities selected, then don't look at m_pDisplayClass.
|
||
|
|
if ( !m_pDisplayClass )
|
||
|
|
{
|
||
|
|
*pState = k_EKeyState_DefaultFGDValue;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *pszCurValue = m_kv.GetValue( pShortName );
|
||
|
|
if ( !pszCurValue )
|
||
|
|
pszCurValue = "";
|
||
|
|
|
||
|
|
// Now see if this var is even in the FGD.
|
||
|
|
GDinputvariable *pVar = m_pDisplayClass->VarForName( pShortName );
|
||
|
|
if ( !pVar )
|
||
|
|
{
|
||
|
|
if ( m_InstanceParmData.Find( pShortName ) != m_InstanceParmData.InvalidIndex() )
|
||
|
|
{
|
||
|
|
*pState = k_EKeyState_InstanceParm;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*pState = k_EKeyState_AddedManually;
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Missing targetname?
|
||
|
|
if ((pVar->GetType() == ivTargetSrc) || (pVar->GetType() == ivTargetDest))
|
||
|
|
{
|
||
|
|
if ( pszCurValue[0] && !IsValidTargetName( pszCurValue ) )
|
||
|
|
*pMissingTarget = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Now we know it's in the FGD, so see if the value has been modified from the default.
|
||
|
|
GDinputvariable varCopy;
|
||
|
|
varCopy = *pVar;
|
||
|
|
MDkeyvalue tmpkv;
|
||
|
|
varCopy.ResetDefaults();
|
||
|
|
varCopy.ToKeyValue( &tmpkv );
|
||
|
|
|
||
|
|
if ( Q_stricmp( pszCurValue, tmpkv.szValue ) == 0 )
|
||
|
|
*pState = k_EKeyState_DefaultFGDValue;
|
||
|
|
else
|
||
|
|
*pState = k_EKeyState_Modified;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::ResortItems()
|
||
|
|
{
|
||
|
|
m_VarList.SortItems( g_ColumnSortFunctions[m_iSortColumn+1], (LPARAM)this );
|
||
|
|
|
||
|
|
// Update m_VarMap if in smart edit mode.
|
||
|
|
if ( m_bSmartedit )
|
||
|
|
{
|
||
|
|
for ( int i=0; i < m_VarList.GetItemCount(); i++ )
|
||
|
|
{
|
||
|
|
const char *pShortName = (const char*)m_VarList.GetItemData( i );
|
||
|
|
if ( !pShortName )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
int index = -1;
|
||
|
|
if ( m_pDisplayClass && m_pDisplayClass->VarForName( pShortName, &index ) )
|
||
|
|
{
|
||
|
|
m_VarMap[i] = index;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
index = m_InstanceParmData.Find( pShortName );
|
||
|
|
if ( index != m_InstanceParmData.InvalidIndex() )
|
||
|
|
{
|
||
|
|
m_VarMap[i] = INSTANCE_VAR_MAP_START - index;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_VarMap[i] = -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void DumpKeyvalues(WCKeyValues &kv)
|
||
|
|
{
|
||
|
|
for (int i = kv.GetFirst(); i != kv.GetInvalidIndex(); i=kv.GetNext( i ) )
|
||
|
|
{
|
||
|
|
DBG(" %d: %s\n", i, kv.GetKey(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Adds an object's keys to our list of keys. If a given key is already
|
||
|
|
// in the list, it is either ignored or set to a "different" if the value
|
||
|
|
// is different from the value in our list.
|
||
|
|
// Input : pEdit - Object whose keys are to be added to our list.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::MergeObjectKeyValues(CEditGameClass *pEdit)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::MergeObjectKeyValues", "Object Properties" );
|
||
|
|
for ( int i=pEdit->GetFirstKeyValue(); i != pEdit->GetInvalidKeyValue(); i=pEdit->GetNextKeyValue( i ) )
|
||
|
|
{
|
||
|
|
LPCTSTR pszCurValue = m_kv.GetValue(pEdit->GetKey(i));
|
||
|
|
if (pszCurValue == NULL)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Doesn't exist yet - set current value.
|
||
|
|
//
|
||
|
|
m_kv.SetValue(pEdit->GetKey(i), pEdit->GetKeyValue(i));
|
||
|
|
}
|
||
|
|
else if (strcmp(pszCurValue, pEdit->GetKeyValue(i)))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Already present - we need to merge the value with the existing data.
|
||
|
|
//
|
||
|
|
MergeKeyValue(pEdit->GetKey(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Updates the dialog's keyvalue data with a given keyvalue. If the
|
||
|
|
// data can be merged in with existing data in a meaningful manner,
|
||
|
|
// that will be done. If not, VALUE_DIFFERENT_STRING will be set to
|
||
|
|
// indicate that not all objects have the same value for the key.
|
||
|
|
// Input : pszKey -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::MergeKeyValue(char const *pszKey)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::MergeKeyValue", "Object Properties" );
|
||
|
|
|
||
|
|
Assert(pszKey);
|
||
|
|
if (!pszKey)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool bHandled = false;
|
||
|
|
|
||
|
|
if (m_pEditClass != NULL)
|
||
|
|
{
|
||
|
|
GDinputvariable *pVar = m_pEditClass->VarForName(pszKey);
|
||
|
|
if (pVar != NULL)
|
||
|
|
{
|
||
|
|
switch (pVar->GetType())
|
||
|
|
{
|
||
|
|
case ivSideList:
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Merging sidelist keys is a little complicated. We build a string
|
||
|
|
// representing the merged sidelists.
|
||
|
|
//
|
||
|
|
CMapFaceIDList FaceIDListFull;
|
||
|
|
CMapFaceIDList FaceIDListPartial;
|
||
|
|
|
||
|
|
GetFaceIDListsForKey(FaceIDListFull, FaceIDListPartial, pszKey);
|
||
|
|
|
||
|
|
char szValue[KEYVALUE_MAX_VALUE_LENGTH];
|
||
|
|
CMapWorld::FaceID_FaceIDListsToString(szValue, sizeof(szValue), &FaceIDListFull, &FaceIDListPartial);
|
||
|
|
m_kv.SetValue(pszKey, szValue);
|
||
|
|
|
||
|
|
bHandled = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case ivAngle:
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// We can't merge angles, so set the appropriate angles control to "different".
|
||
|
|
// We'll catch the main angles control below, since it's supported even
|
||
|
|
// for objects of an unknown class.
|
||
|
|
//
|
||
|
|
if (stricmp(pVar->GetName(), "angles"))
|
||
|
|
{
|
||
|
|
m_SmartAngle.SetDifferent(true);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!bHandled)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Can't merge with current value - show a "different" string.
|
||
|
|
//
|
||
|
|
m_kv.SetValue(pszKey, VALUE_DIFFERENT_STRING);
|
||
|
|
|
||
|
|
if (!stricmp(pszKey, "angles"))
|
||
|
|
{
|
||
|
|
// We can't merge angles, so set the main angles control to "different".
|
||
|
|
m_Angle.SetDifferent(true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : Mode -
|
||
|
|
// pData -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::UpdateData( int Mode, PVOID pData, bool bCanEdit )
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::UpdateData", "Object Properties" );
|
||
|
|
|
||
|
|
//DBG("UpdateData\n");
|
||
|
|
//DumpKeyvalues(m_kv);
|
||
|
|
|
||
|
|
__super::UpdateData( Mode, pData, bCanEdit );
|
||
|
|
|
||
|
|
if (!IsWindow(m_hWnd))
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (GetFocus() == &m_cKey)
|
||
|
|
{
|
||
|
|
OnKillfocusKey();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Mode == LoadFinished)
|
||
|
|
{
|
||
|
|
m_kvAdded.RemoveAll();
|
||
|
|
m_bAllowPresentProperties = true;
|
||
|
|
PresentProperties();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
else if ( Mode == LoadData || Mode == LoadFirstData )
|
||
|
|
{
|
||
|
|
// Wait until the LoadFinished call to create all the controls,
|
||
|
|
// otherwise it'll do a lot of unnecessary work.
|
||
|
|
m_bAllowPresentProperties = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!pData)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
CEditGameClass *pEdit = (CEditGameClass *)pData;
|
||
|
|
char szBuf[KEYVALUE_MAX_VALUE_LENGTH];
|
||
|
|
|
||
|
|
if (Mode == LoadFirstData)
|
||
|
|
{
|
||
|
|
LoadClassList();
|
||
|
|
|
||
|
|
m_nNewKeyCount = 1;
|
||
|
|
|
||
|
|
QAngle vecAngles;
|
||
|
|
pEdit->GetAngles(vecAngles);
|
||
|
|
m_Angle.SetAngles(vecAngles, false);
|
||
|
|
m_Angle.SetDifferent(false);
|
||
|
|
|
||
|
|
#ifdef NAMES
|
||
|
|
if(pEdit->pClass)
|
||
|
|
{
|
||
|
|
sprintf(szBuf, "%s (%s)", pEdit->pClass->GetDescription(), pEdit->pClass->GetName());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
#endif
|
||
|
|
|
||
|
|
V_strcpy_safe( szBuf, pEdit->GetClassName() );
|
||
|
|
m_cClasses.AddSuggestion( szBuf ); // If we don't make sure it has this item in its list, it will do
|
||
|
|
// Bad Things later on. This only happens when the FGD is missing an
|
||
|
|
// entity that is in the map file. In that case, just let it be.
|
||
|
|
// Check For Problems should ID the problem for them.
|
||
|
|
m_cClasses.SelectItem(szBuf);
|
||
|
|
m_bClassSelectionEmpty = false;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Can't change the class of the worldspawn entity.
|
||
|
|
//
|
||
|
|
if ( pEdit->IsClass("worldspawn") || m_bCanEdit == false )
|
||
|
|
{
|
||
|
|
m_cClasses.EnableWindow(FALSE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_cClasses.EnableWindow(TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Get the comments text from the entity.
|
||
|
|
//
|
||
|
|
m_Comments.SetWindowText(pEdit->GetComments());
|
||
|
|
|
||
|
|
//
|
||
|
|
// Add entity's keys to our local storage
|
||
|
|
//
|
||
|
|
m_kv.RemoveAll();
|
||
|
|
for ( int i=pEdit->GetFirstKeyValue(); i != pEdit->GetInvalidKeyValue(); i=pEdit->GetNextKeyValue( i ) )
|
||
|
|
{
|
||
|
|
const char *pszKey = pEdit->GetKey(i);
|
||
|
|
const char *pszValue = pEdit->GetKeyValue(i);
|
||
|
|
if ((pszKey != NULL) && (pszValue != NULL))
|
||
|
|
{
|
||
|
|
m_kv.SetValue(pszKey, pszValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdateEditClass(pEdit->GetClassName(), true);
|
||
|
|
UpdateDisplayClass(pEdit->GetClassName());
|
||
|
|
|
||
|
|
SetCurKey(m_strLastKey);
|
||
|
|
}
|
||
|
|
else if (Mode == LoadData)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Not first data - merge with current stuff.
|
||
|
|
//
|
||
|
|
|
||
|
|
//
|
||
|
|
// Deal with class name.
|
||
|
|
//
|
||
|
|
CString str = m_cClasses.GetCurrentItem();
|
||
|
|
if ( m_bClassSelectionEmpty )
|
||
|
|
str = "";
|
||
|
|
|
||
|
|
if (strcmpi(str, pEdit->GetClassName()))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Not the same - set class to be blank and
|
||
|
|
// disable smartedit.
|
||
|
|
//
|
||
|
|
m_cClasses.ForceEditControlText( "" );
|
||
|
|
m_bClassSelectionEmpty = true;
|
||
|
|
|
||
|
|
UpdateEditClass("", false);
|
||
|
|
UpdateDisplayClass("");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
LoadClassList();
|
||
|
|
m_cClasses.SelectItem( pEdit->GetClassName() );
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Mark the comments field as "(different)" if it isn't the same as this entity's
|
||
|
|
// comments.
|
||
|
|
//
|
||
|
|
char szComments[1024];
|
||
|
|
m_Comments.GetWindowText(szComments, sizeof(szComments));
|
||
|
|
if (strcmp(szComments, pEdit->GetComments()) != 0)
|
||
|
|
{
|
||
|
|
m_Comments.SetWindowText(VALUE_DIFFERENT_STRING);
|
||
|
|
}
|
||
|
|
|
||
|
|
MergeObjectKeyValues(pEdit);
|
||
|
|
SetCurKey(m_strLastKey);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Assert(FALSE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Stops entity, face, or angles picking.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::StopPicking(void)
|
||
|
|
{
|
||
|
|
if (m_bPicking)
|
||
|
|
{
|
||
|
|
m_bPicking = false;
|
||
|
|
ToolManager()->SetTool(m_ToolPrePick);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Stop angles picking if we are doing so.
|
||
|
|
//
|
||
|
|
CButton *pButton = (CButton *)GetDlgItem(IDC_PICK_ANGLES);
|
||
|
|
if (pButton)
|
||
|
|
{
|
||
|
|
pButton->SetCheck(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Stop entity picking if we are doing so.
|
||
|
|
//
|
||
|
|
pButton = (CButton *)GetDlgItem(IDC_PICK_ENTITY);
|
||
|
|
if (pButton)
|
||
|
|
{
|
||
|
|
pButton->SetCheck(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Stop face picking if we are doing so.
|
||
|
|
//
|
||
|
|
pButton = (CButton *)GetDlgItem(IDC_PICK_FACES);
|
||
|
|
if (pButton)
|
||
|
|
{
|
||
|
|
pButton->SetCheck(0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Called manually from CObjectProperties::OnApply because the Apply
|
||
|
|
// button is implemented in a nonstandard way. I'm not sure why.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
BOOL COP_Entity::OnApply(void)
|
||
|
|
{
|
||
|
|
m_pLastSmartControlVar = NULL; // Force it to recreate the target name combo if need be,
|
||
|
|
// because we might have locked in a new targetname.
|
||
|
|
StopPicking();
|
||
|
|
return(TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pEntity -
|
||
|
|
// pszKey -
|
||
|
|
// pszValue -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::ApplyKeyValueToObject(CEditGameClass *pObject, const char *pszKey, const char *pszValue)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::ApplyKeyValueToObject", "Object Properties" );
|
||
|
|
|
||
|
|
GDclass *pClass = pObject->GetClass();
|
||
|
|
if (pClass != NULL)
|
||
|
|
{
|
||
|
|
GDinputvariable *pVar = pClass->VarForName(pszKey);
|
||
|
|
if (pVar != NULL)
|
||
|
|
{
|
||
|
|
if ((pVar->GetType() == ivSideList) || (pVar->GetType() == ivSide))
|
||
|
|
{
|
||
|
|
CMapWorld *pWorld = GetActiveWorld();
|
||
|
|
|
||
|
|
//
|
||
|
|
// Get the face list currently set in this keyvalue.
|
||
|
|
//
|
||
|
|
CMapFaceIDList CurFaceList;
|
||
|
|
const char *pszCurVal = pObject->GetKeyValue(pszKey);
|
||
|
|
if (pszCurVal != NULL)
|
||
|
|
{
|
||
|
|
pWorld->FaceID_StringToFaceIDLists(&CurFaceList, NULL, pszCurVal);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Build the face list to apply. Only include the faces that are:
|
||
|
|
//
|
||
|
|
// 1. In the full selection list (outside the parentheses).
|
||
|
|
// 2. In the partial selection set (inside the parentheses) AND are in the
|
||
|
|
// original face list.
|
||
|
|
//
|
||
|
|
// FACEID TODO: Optimize so that we only call StringToFaceList once per keyvalue
|
||
|
|
// instead of once per keyvalue per entity being applied to.
|
||
|
|
CMapFaceIDList FullFaceList;
|
||
|
|
CMapFaceIDList PartialFaceList;
|
||
|
|
pWorld->FaceID_StringToFaceIDLists(&FullFaceList, &PartialFaceList, pszValue);
|
||
|
|
|
||
|
|
CMapFaceIDList KeepFaceList;
|
||
|
|
for (int i = 0; i < PartialFaceList.Count(); i++)
|
||
|
|
{
|
||
|
|
int nFace = PartialFaceList.Element(i);
|
||
|
|
|
||
|
|
if (CurFaceList.Find(nFace) != -1)
|
||
|
|
{
|
||
|
|
KeepFaceList.AddToTail(nFace);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
FullFaceList.AddVectorToTail(KeepFaceList);
|
||
|
|
|
||
|
|
char szSetValue[KEYVALUE_MAX_VALUE_LENGTH];
|
||
|
|
CMapWorld::FaceID_FaceIDListsToString(szSetValue, sizeof(szSetValue), &FullFaceList, NULL);
|
||
|
|
|
||
|
|
pObject->SetKeyValue(pszKey, szSetValue);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pObject->SetKeyValue(pszKey, pszValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Called by the sheet to let the page remember its state before a
|
||
|
|
// refresh of the data.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::RememberState(void)
|
||
|
|
{
|
||
|
|
GetCurKey(m_strLastKey);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Called by the object properties page to tell us that all our data
|
||
|
|
// is dirty. We don't have to do anything on most of our data because it'll
|
||
|
|
// get regenerated, but we must clear out our class pointers because we'll
|
||
|
|
// do crazy things if they give us a new class and have us load the data
|
||
|
|
// (we'll think it just changed from one class to another and we'll wipe
|
||
|
|
// out spawnflags, for instance). So clear out the class pointers.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::MarkDataDirty()
|
||
|
|
{
|
||
|
|
UpdateDisplayClass( (GDclass*)NULL );
|
||
|
|
m_pEditClass = NULL;
|
||
|
|
m_VarList.DeleteAllItems();
|
||
|
|
m_InstanceParmData.RemoveAll();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Saves the dialog data into the objects being edited.
|
||
|
|
// Output : Returns true on success, false on failure.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool COP_Entity::SaveData(void)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::SaveData", "Object Properties" );
|
||
|
|
|
||
|
|
//DBG("SaveData\n");
|
||
|
|
//DumpKeyvalues(m_kv);
|
||
|
|
|
||
|
|
RememberState();
|
||
|
|
|
||
|
|
CString strClassName = m_cClasses.GetCurrentItem();
|
||
|
|
|
||
|
|
// If we were multiselecting entities and they haven't chosen a new classname yet,
|
||
|
|
// we need to know that here so we don't force them all to be the last selection in the classname combo.
|
||
|
|
if ( m_bClassSelectionEmpty )
|
||
|
|
strClassName = "";
|
||
|
|
|
||
|
|
UpdateEditClass(strClassName, false);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Apply the dialog data to all the objects being edited.
|
||
|
|
//
|
||
|
|
FOR_EACH_OBJ( *m_pObjectList, pos )
|
||
|
|
{
|
||
|
|
CMapClass *pObject = m_pObjectList->Element(pos);
|
||
|
|
CEditGameClass *pEdit = dynamic_cast <CEditGameClass *>(pObject);
|
||
|
|
Assert(pEdit != NULL);
|
||
|
|
|
||
|
|
if (pEdit != NULL)
|
||
|
|
{
|
||
|
|
RemoveBlankKeys();
|
||
|
|
|
||
|
|
//
|
||
|
|
// Give keys back to object. For every key in our local storage that is
|
||
|
|
// also found in the list of added keys, set the key value in the edit
|
||
|
|
// object(s).
|
||
|
|
//
|
||
|
|
for (int i = m_kv.GetFirst(); i != m_kv.GetInvalidIndex(); i=m_kv.GetNext( i ) )
|
||
|
|
{
|
||
|
|
MDkeyvalue &kvCur = m_kv.GetKeyValue(i);
|
||
|
|
const char *pszAddedKeyValue = m_kvAdded.GetValue(kvCur.szKey);
|
||
|
|
if (pszAddedKeyValue != NULL)
|
||
|
|
{
|
||
|
|
Q_FixSlashes( kvCur.szValue, '/' );
|
||
|
|
//
|
||
|
|
// Don't store keys with multiple/undefined values.
|
||
|
|
//
|
||
|
|
if (strcmp(kvCur.szValue, VALUE_DIFFERENT_STRING))
|
||
|
|
{
|
||
|
|
//DBG(" apply key %s\n", kvCur.szKey);
|
||
|
|
ApplyKeyValueToObject(pEdit, kvCur.szKey, kvCur.szValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// All keys in the object should also be found in local storage,
|
||
|
|
// unless the user deleted them. If there are any such extraneous
|
||
|
|
// keys, get rid of them. Go from the top down because otherwise
|
||
|
|
// deleting messes up our iteration.
|
||
|
|
//
|
||
|
|
int iNext;
|
||
|
|
for ( int i=pEdit->GetFirstKeyValue(); i != pEdit->GetInvalidKeyValue(); i=iNext )
|
||
|
|
{
|
||
|
|
iNext = pEdit->GetNextKeyValue( i );
|
||
|
|
//
|
||
|
|
// If this key is in not in our local storage, delete it from the object.
|
||
|
|
//
|
||
|
|
if (!m_kv.GetValue(pEdit->GetKey(i)))
|
||
|
|
{
|
||
|
|
//DBG(" delete key %s\n", pEdit->GetKey(i));
|
||
|
|
pEdit->DeleteKeyValue(pEdit->GetKey(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Store class.
|
||
|
|
//
|
||
|
|
if (strClassName[0])
|
||
|
|
{
|
||
|
|
pEdit->SetClass(strClassName);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Store the entity comments.
|
||
|
|
//
|
||
|
|
char szComments[1024];
|
||
|
|
szComments[0] = '\0';
|
||
|
|
m_Comments.GetWindowText(szComments, sizeof(szComments));
|
||
|
|
if (strcmp(szComments, VALUE_DIFFERENT_STRING) != 0)
|
||
|
|
{
|
||
|
|
pEdit->SetComments(szComments);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pObject->PostUpdate(Notify_Changed);
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdateDisplayClass(strClassName);
|
||
|
|
|
||
|
|
return(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Given the short name of a key, find which row it's at in the list control.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
int COP_Entity::GetKeyValueRowByShortName( const char *pShortName )
|
||
|
|
{
|
||
|
|
const char *pSearchString = pShortName;
|
||
|
|
if ( m_bSmartedit )
|
||
|
|
{
|
||
|
|
if ( m_pDisplayClass )
|
||
|
|
{
|
||
|
|
GDinputvariable *pVar = m_pDisplayClass->VarForName( pShortName );
|
||
|
|
if (pVar)
|
||
|
|
pSearchString = pVar->GetLongName();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
LVFINDINFO fi;
|
||
|
|
memset( &fi, 0, sizeof( fi ) );
|
||
|
|
fi.flags = LVFI_STRING;
|
||
|
|
fi.psz = pSearchString;
|
||
|
|
return m_VarList.FindItem( &fi );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Fills the values in the second column for all properties.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::RefreshKVListValues( const char *pOnlyThisVar )
|
||
|
|
{
|
||
|
|
// We match listctrl elements to their values in 2 different ways:
|
||
|
|
// 1. In smartedit mode, the raw name of the property in the first column is matched to m_kv.
|
||
|
|
// 2. In non-smartedit mode, we look at the lParam entry in the listctrl.
|
||
|
|
for ( int i=0; i < m_VarList.GetItemCount(); i++ )
|
||
|
|
{
|
||
|
|
const char *pVarName = (const char*)m_VarList.GetItemData( i );
|
||
|
|
const char *pValue = NULL;
|
||
|
|
char tmpValueBuf[512];
|
||
|
|
|
||
|
|
// If they only wanted to update one var...
|
||
|
|
if ( pOnlyThisVar && Q_stricmp( pVarName, pOnlyThisVar ) != 0 )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if ( m_bSmartedit )
|
||
|
|
{
|
||
|
|
GDinputvariable *pVar = (m_pDisplayClass ? m_pDisplayClass->VarForName( pVarName ) : NULL);
|
||
|
|
if ( pVar )
|
||
|
|
{
|
||
|
|
const char *pUnformattedValue = m_kv.GetValue( pVar->GetName() );
|
||
|
|
pValue = pUnformattedValue; // Default is unformatted.
|
||
|
|
|
||
|
|
if ( pUnformattedValue )
|
||
|
|
{
|
||
|
|
// Do special formatting for various value types.
|
||
|
|
GDIV_TYPE eType = pVar->GetType();
|
||
|
|
if ( eType == ivChoices )
|
||
|
|
{
|
||
|
|
if ( pUnformattedValue )
|
||
|
|
{
|
||
|
|
const char *pTestValue = pVar->ItemStringForValue( pUnformattedValue );
|
||
|
|
if ( pTestValue )
|
||
|
|
pValue = pTestValue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (
|
||
|
|
(eType == ivStudioModel) || (eType == ivSprite) || (eType == ivSound) || (eType == ivDecal) ||
|
||
|
|
(eType == ivMaterial) || (eType == ivScene) )
|
||
|
|
{
|
||
|
|
// It's a filename.. just show the filename and not the directory. They can look at the
|
||
|
|
// full filename in the smart control if they want.
|
||
|
|
const char *pLastSlash = max( strrchr( pUnformattedValue, '\\' ), strrchr( pUnformattedValue, '/' ) );
|
||
|
|
if ( pLastSlash )
|
||
|
|
{
|
||
|
|
Q_strncpy( tmpValueBuf, pLastSlash+1, sizeof( tmpValueBuf ) );
|
||
|
|
pValue = tmpValueBuf;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pValue = m_kv.GetValue( pVarName ); // This was probably added in dumbedit mode.
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pValue = m_kv.GetValue( pVarName );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( pValue )
|
||
|
|
m_VarList.SetItemText( i, 1, pValue );
|
||
|
|
else
|
||
|
|
m_VarList.SetItemText( i, 1, "" );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Sets up the current mode (smartedit/non) after loading an object
|
||
|
|
// or toggling the SmartEdit button.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::PresentProperties()
|
||
|
|
{
|
||
|
|
if ( !m_bAllowPresentProperties )
|
||
|
|
return;
|
||
|
|
|
||
|
|
++m_nPresentPropertiesCalls;
|
||
|
|
|
||
|
|
m_VarList.SetRedraw( FALSE );
|
||
|
|
ClearVarList();
|
||
|
|
|
||
|
|
if (!m_bSmartedit || !m_pDisplayClass)
|
||
|
|
{
|
||
|
|
RemoveBlankKeys();
|
||
|
|
|
||
|
|
for (int i = m_kv.GetFirst(); i != m_kv.GetInvalidIndex(); i=m_kv.GetNext( i ) )
|
||
|
|
{
|
||
|
|
MDkeyvalue &KeyValue = m_kv.GetKeyValue(i);
|
||
|
|
|
||
|
|
int iItem = m_VarList.InsertItem( i, KeyValue.szKey );
|
||
|
|
m_VarList.SetItemData( iItem, (DWORD)KeyValue.szKey );
|
||
|
|
}
|
||
|
|
|
||
|
|
m_Angle.Enable( m_bCanEdit );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Too many entity variables! Increase GD_MAX_VARIABLES if you get this assertion.
|
||
|
|
Assert(m_pDisplayClass->GetVariableCount() <= GD_MAX_VARIABLES);
|
||
|
|
|
||
|
|
for ( int i=0; i < ARRAYSIZE(m_VarMap); i++ )
|
||
|
|
{
|
||
|
|
m_VarMap[i] = -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Add all the keys from the entity's class to the listbox. If the key is not already
|
||
|
|
// in the entity, add it to the m_kvAdded list as well.
|
||
|
|
//
|
||
|
|
for (int i = 0; i < m_pDisplayClass->GetVariableCount(); i++)
|
||
|
|
{
|
||
|
|
GDinputvariable *pVar = m_pDisplayClass->GetVariableAt(i);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Spawnflags are handled separately - don't add that key.
|
||
|
|
//
|
||
|
|
if (strcmpi(pVar->GetName(), SPAWNFLAGS_KEYNAME) != 0)
|
||
|
|
{
|
||
|
|
int iItem = m_VarList.InsertItem( i, pVar->GetLongName() );
|
||
|
|
m_VarList.SetItemData( iItem, (DWORD)pVar->GetName() );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_pObjectList->Count() == 1 )
|
||
|
|
{
|
||
|
|
CMapEntity *pEntity = static_cast< CMapEntity * >( m_pObjectList->Element( 0 ) );
|
||
|
|
|
||
|
|
CMapInstance *pMapInstance = pEntity->GetChildOfType( ( CMapInstance * )NULL );
|
||
|
|
if ( pMapInstance && pMapInstance->GetInstancedMap() )
|
||
|
|
{
|
||
|
|
CMapEntityList entityList;
|
||
|
|
|
||
|
|
pMapInstance->GetInstancedMap()->FindEntitiesByClassName( entityList, "func_instance_parms", false );
|
||
|
|
if ( entityList.Count() == 1 )
|
||
|
|
{
|
||
|
|
CMapEntity *pInstanceParmsEntity = entityList.Element( 0 );
|
||
|
|
|
||
|
|
for ( int i = pInstanceParmsEntity->GetFirstKeyValue(); i != pInstanceParmsEntity->GetInvalidKeyValue(); i = pInstanceParmsEntity->GetNextKeyValue( i ) )
|
||
|
|
{
|
||
|
|
LPCTSTR pInstanceKey = pInstanceParmsEntity->GetKey( i );
|
||
|
|
LPCTSTR pInstanceValue = pInstanceParmsEntity->GetKeyValue( i );
|
||
|
|
|
||
|
|
if ( strnicmp( pInstanceKey, "parm", strlen( "parm" ) ) == 0 )
|
||
|
|
{
|
||
|
|
char ValueData[ KEYVALUE_MAX_KEY_LENGTH ];
|
||
|
|
const char *pVariable, *pReplace;
|
||
|
|
|
||
|
|
pVariable = pReplace = "";
|
||
|
|
if ( pInstanceValue )
|
||
|
|
{
|
||
|
|
strcpy( ValueData, pInstanceValue );
|
||
|
|
pVariable = ValueData;
|
||
|
|
char *pos = strchr( ValueData, ' ' );
|
||
|
|
if ( pos )
|
||
|
|
{
|
||
|
|
*pos = 0;
|
||
|
|
pos++;
|
||
|
|
pReplace = pos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int j = pEntity->GetFirstKeyValue(); j != pEntity->GetInvalidKeyValue(); j = pEntity->GetNextKeyValue( j ) )
|
||
|
|
{
|
||
|
|
LPCTSTR pKey = pEntity->GetKey( j );
|
||
|
|
LPCTSTR pValue = pEntity->GetKeyValue( j );
|
||
|
|
|
||
|
|
if ( strnicmp( pValue, pVariable, strlen( pVariable ) ) == 0 )
|
||
|
|
{
|
||
|
|
CInstanceParmData InstanceParmData;
|
||
|
|
|
||
|
|
InstanceParmData.m_ParmVariable = new GDinputvariable( pReplace, pVariable );
|
||
|
|
InstanceParmData.m_ParmKey = pKey;
|
||
|
|
InstanceParmData.m_VariableName = pVariable;
|
||
|
|
int InsertIndex = m_InstanceParmData.Insert( InstanceParmData.m_VariableName, InstanceParmData );
|
||
|
|
|
||
|
|
const char *ptr = m_InstanceParmData[ InsertIndex ].m_VariableName;
|
||
|
|
int iItem = m_VarList.InsertItem( 0, ptr );
|
||
|
|
m_VarList.SetItemData( iItem, (DWORD)ptr );
|
||
|
|
m_kv.SetValue( pVariable, pValue + strlen( pVariable ) + 1 );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// rj: this must be after the instancing check above, as adding keyvalues to m_kv can cause the list to get reallocated, causing the SetItemData to have an invalid pointer
|
||
|
|
// Also add any keyvalues they added in dumbedit mode. These will show up in red.
|
||
|
|
for (int i = m_kv.GetFirst(); i != m_kv.GetInvalidIndex(); i=m_kv.GetNext( i ) )
|
||
|
|
{
|
||
|
|
MDkeyvalue &KeyValue = m_kv.GetKeyValue(i);
|
||
|
|
|
||
|
|
if ( !m_pDisplayClass->VarForName( KeyValue.szKey ) && m_InstanceParmData.Find( KeyValue.szKey ) == m_InstanceParmData.InvalidIndex() )
|
||
|
|
{
|
||
|
|
int iItem = m_VarList.InsertItem( i, KeyValue.szKey );
|
||
|
|
m_VarList.SetItemData( iItem, (DWORD)KeyValue.szKey );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If this class defines angles, enable the angles control.
|
||
|
|
//
|
||
|
|
if (m_pDisplayClass->VarForName("angles") != NULL)
|
||
|
|
{
|
||
|
|
m_Angle.Enable( m_bCanEdit );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_Angle.Enable(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
RefreshKVListValues();
|
||
|
|
ResortItems();
|
||
|
|
|
||
|
|
SetCurKey(m_strLastKey);
|
||
|
|
m_VarList.SetRedraw( TRUE );
|
||
|
|
m_VarList.Invalidate( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::ClearVarList()
|
||
|
|
{
|
||
|
|
m_VarList.DeleteAllItems();
|
||
|
|
m_InstanceParmData.RemoveAll();
|
||
|
|
|
||
|
|
for ( int i=0; i < ARRAYSIZE( m_VarMap ); i++ )
|
||
|
|
m_VarMap[i] = -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Removes any keys with blank values from our local keyvalue storage.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::RemoveBlankKeys(void)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::RemoveBlankKeys", "Object Properties" );
|
||
|
|
|
||
|
|
int iNext;
|
||
|
|
for (int i = m_kv.GetFirst(); i != m_kv.GetInvalidIndex(); i=iNext)
|
||
|
|
{
|
||
|
|
iNext = m_kv.GetNext( i );
|
||
|
|
|
||
|
|
MDkeyvalue &KeyValue = m_kv.GetKeyValue(i);
|
||
|
|
if (KeyValue.szValue[0] == '\0')
|
||
|
|
{
|
||
|
|
bool bRemove = true;
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
// Only remove keys that are blank and whose default value is not blank,
|
||
|
|
// because Hammer assigns any missing key with the FGD's default value.
|
||
|
|
//
|
||
|
|
// dvs: disabled for now because deleting the value text is the currently
|
||
|
|
// accepted way of reverting a key to its default value.
|
||
|
|
GDinputvariable *pVar = m_pDisplayClass->VarForName( KeyValue.szKey );
|
||
|
|
if ( pVar )
|
||
|
|
{
|
||
|
|
char szDefault[MAX_KEYVALUE_LEN];
|
||
|
|
pVar->GetDefault( szDefault );
|
||
|
|
if ( szDefault[0] != '\0' )
|
||
|
|
{
|
||
|
|
bRemove = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
if ( bRemove )
|
||
|
|
{
|
||
|
|
m_kv.RemoveKeyAt(i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::LoadClassList(void)
|
||
|
|
{
|
||
|
|
CEditGameClass *pEdit = (CEditGameClass*) GetEditObject();
|
||
|
|
const char *pWorldSpawnString = "worldspawn";
|
||
|
|
int iSolidClasses = -1;
|
||
|
|
|
||
|
|
if (pEdit->IsClass())
|
||
|
|
{
|
||
|
|
if ( pEdit->IsClass( pWorldSpawnString ) )
|
||
|
|
{
|
||
|
|
iSolidClasses = 2;
|
||
|
|
}
|
||
|
|
else if (pEdit->IsSolidClass())
|
||
|
|
{
|
||
|
|
iSolidClasses = 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
iSolidClasses = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ok, we've already initialized the list with the same list. Don't do it over again.
|
||
|
|
if ( m_iLastClassListSolidClasses == iSolidClasses )
|
||
|
|
return;
|
||
|
|
|
||
|
|
CUtlVector<CString> suggestions;
|
||
|
|
if ( iSolidClasses == 2 )
|
||
|
|
{
|
||
|
|
suggestions.AddToTail( pWorldSpawnString );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
int nCount = pGD->GetClassCount();
|
||
|
|
CString str;
|
||
|
|
for (int i =0; i < nCount; i++)
|
||
|
|
{
|
||
|
|
GDclass *pc = pGD->GetClass(i);
|
||
|
|
if (!pc->IsBaseClass())
|
||
|
|
{
|
||
|
|
if (iSolidClasses == -1 || (iSolidClasses == (int)pc->IsSolidClass()))
|
||
|
|
{
|
||
|
|
#ifdef NAMES
|
||
|
|
str.Format("%s (%s)", pc->GetDescription(), pc->GetName());
|
||
|
|
#else
|
||
|
|
str = pc->GetName();
|
||
|
|
#endif
|
||
|
|
|
||
|
|
if (!pc->IsClass( pWorldSpawnString ))
|
||
|
|
{
|
||
|
|
suggestions.AddToTail( str );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_iLastClassListSolidClasses = iSolidClasses;
|
||
|
|
m_cClasses.SetSuggestions( suggestions, 0 );
|
||
|
|
|
||
|
|
// Add this class' class name in case it's not in the list yet.
|
||
|
|
m_cClasses.AddSuggestion( pEdit->GetClassNameA() );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
BOOL COP_Entity::OnInitDialog(void)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::OnInitDialog", "Object Properties" );
|
||
|
|
|
||
|
|
CObjectPage::OnInitDialog();
|
||
|
|
|
||
|
|
// Sometimes it has deleted our window (and its children) from underneath us,
|
||
|
|
// and we don't want to hang onto old window pointers.
|
||
|
|
m_SmartControls.Purge();
|
||
|
|
m_pDisplayClass = NULL;
|
||
|
|
m_pEditClass = NULL;
|
||
|
|
m_pLastSmartControlVar = NULL;
|
||
|
|
|
||
|
|
// Clear m_kv.
|
||
|
|
m_kv.RemoveAll();
|
||
|
|
ClearVarList();
|
||
|
|
|
||
|
|
// Hook up the main angles controls.
|
||
|
|
m_Angle.SubclassDlgItem(IDC_ANGLEBOX, this);
|
||
|
|
m_AngleEdit.SubclassDlgItem(IDC_ANGLEEDIT, this);
|
||
|
|
m_Angle.SetEditControl(&m_AngleEdit);
|
||
|
|
m_AngleEdit.SetAngleBox(&m_Angle);
|
||
|
|
|
||
|
|
// Hook up the smart angles controls.
|
||
|
|
m_SmartAngle.SubclassDlgItem(IDC_SMART_ANGLEBOX, this);
|
||
|
|
m_SmartAngleEdit.SubclassDlgItem(IDC_SMART_ANGLEEDIT, this);
|
||
|
|
m_SmartAngle.SetEditControl(&m_SmartAngleEdit);
|
||
|
|
m_SmartAngleEdit.SetAngleBox(&m_SmartAngle);
|
||
|
|
|
||
|
|
// Hook up the classes autoselect combo.
|
||
|
|
m_cClasses.SubclassDlgItem(IDC_CLASS, this);
|
||
|
|
|
||
|
|
// Hook up the pick color button.
|
||
|
|
m_cPickColor.SubclassDlgItem(IDC_PICKCOLOR, this);
|
||
|
|
|
||
|
|
LoadClassList();
|
||
|
|
|
||
|
|
//m_VarList.SetTabStops(65);
|
||
|
|
|
||
|
|
// Put our varlist in the right mode.
|
||
|
|
DWORD dwStyle = GetWindowLong( m_VarList.GetSafeHwnd(), GWL_STYLE );
|
||
|
|
dwStyle &= ~(LVS_ICON | LVS_LIST | LVS_SMALLICON);
|
||
|
|
dwStyle |= LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS | LVS_OWNERDRAWFIXED;
|
||
|
|
SetWindowLong( m_VarList.GetSafeHwnd(), GWL_STYLE, dwStyle );
|
||
|
|
|
||
|
|
m_VarList.SetExtendedStyle( m_VarList.GetExtendedStyle() | LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES );
|
||
|
|
m_VarList.InsertColumn(0, "Property Name", LVCFMT_LEFT, 200);
|
||
|
|
m_VarList.InsertColumn(1, "Value", LVCFMT_LEFT, 150);
|
||
|
|
|
||
|
|
m_bWantSmartedit = true;
|
||
|
|
SetSmartedit(false);
|
||
|
|
|
||
|
|
UpdateAnchors();
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::UpdateAnchors()
|
||
|
|
{
|
||
|
|
CAnchorDef anchorDefs[] =
|
||
|
|
{
|
||
|
|
CAnchorDef( IDC_KEYVALUES, k_eSimpleAnchorAllSides ),
|
||
|
|
CAnchorDef( IDC_SMARTEDIT, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_ENTITY_HELP, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_ANGLES_LABEL, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_ANGLEEDIT, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_ANGLEBOX, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_KEY_LABEL, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_KEY, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_VALUE_LABEL, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_PICKCOLOR, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_SMART_ANGLEEDIT, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_SMART_ANGLEBOX, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_VALUE, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_KEYVALUE_HELP_GROUP, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_KEYVALUE_HELP, k_eAnchorRight, k_eAnchorTop, k_eAnchorRight, k_eAnchorBottom ),
|
||
|
|
CAnchorDef( IDC_COMMENTS_LABEL, k_eSimpleAnchorBottomRight ),
|
||
|
|
CAnchorDef( IDC_ENTITY_COMMENTS, k_eAnchorRight, k_eAnchorBottom, k_eAnchorRight, k_eAnchorBottom ),
|
||
|
|
CAnchorDef( IDC_ADDKEYVALUE, k_eSimpleAnchorRightSide ),
|
||
|
|
CAnchorDef( IDC_REMOVEKEYVALUE, k_eSimpleAnchorRightSide )
|
||
|
|
};
|
||
|
|
CUtlVector<CAnchorDef> defs;
|
||
|
|
defs.CopyArray( anchorDefs, ARRAYSIZE( anchorDefs ) );
|
||
|
|
|
||
|
|
for ( int i=0; i < m_SmartControls.Count(); i++ )
|
||
|
|
{
|
||
|
|
defs.AddToTail( CAnchorDef( m_SmartControls[i]->GetSafeHwnd(), k_eSimpleAnchorRightSide ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
m_AnchorMgr.Init( GetSafeHwnd(), defs.Base(), defs.Count() );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int COP_Entity::GetCurVarListSelection()
|
||
|
|
{
|
||
|
|
POSITION pos = m_VarList.GetFirstSelectedItemPosition();
|
||
|
|
if ( pos )
|
||
|
|
{
|
||
|
|
return m_VarList.GetNextSelectedItem( pos );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return LB_ERR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::OnItemChangedKeyValues(NMHDR* pNMHDR, LRESULT* pResult)
|
||
|
|
{
|
||
|
|
OnSelchangeKeyvalues();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::OnDblClickKeyValues(NMHDR* pNMHDR, LRESULT* pResult)
|
||
|
|
{
|
||
|
|
// Do smart stuff if we're in SmartEdit mode.
|
||
|
|
if ( !m_bSmartedit )
|
||
|
|
return;
|
||
|
|
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
if ( iSel == LB_ERR )
|
||
|
|
return;
|
||
|
|
|
||
|
|
GDinputvariable *pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( pVar->GetType() == ivColor255 || pVar->GetType() == ivColor1 )
|
||
|
|
{
|
||
|
|
OnPickColor();
|
||
|
|
}
|
||
|
|
else if ( m_pSmartControl )
|
||
|
|
{
|
||
|
|
if ( m_pSmartBrowseButton )
|
||
|
|
{
|
||
|
|
OnBrowse();
|
||
|
|
}
|
||
|
|
else if ( dynamic_cast< CMyEdit* >( m_pSmartControl ) )
|
||
|
|
{
|
||
|
|
m_pSmartControl->SetFocus();
|
||
|
|
m_pSmartControl->SendMessage( EM_SETSEL, 0, -1 );
|
||
|
|
}
|
||
|
|
else if ( dynamic_cast< CMyComboBox* >( m_pSmartControl ) || dynamic_cast< CTargetNameComboBox* >( m_pSmartControl ) )
|
||
|
|
{
|
||
|
|
m_pSmartControl->SetFocus();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::SetCurVarListSelection( int iSel )
|
||
|
|
{
|
||
|
|
// Deselect everything.
|
||
|
|
POSITION pos = m_VarList.GetFirstSelectedItemPosition();
|
||
|
|
while ( pos )
|
||
|
|
{
|
||
|
|
int iItem = m_VarList.GetNextSelectedItem( pos );
|
||
|
|
m_VarList.SetItemState( iItem, 0, LVIS_SELECTED );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Now set selection on the item we want.
|
||
|
|
m_VarList.SetItemState( iSel, LVIS_SELECTED, LVIS_SELECTED );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Gets the name of the currently selected key in the properties list.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::GetCurKey(CString &strKey)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::GetCurKey", "Object Properties" );
|
||
|
|
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
if (iSel == -1)
|
||
|
|
{
|
||
|
|
strKey = "";
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
strKey = (CString)(const char*)m_VarList.GetItemData( iSel );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Selects the given key in the list of keys. If the key is not in the
|
||
|
|
// list, the first key is selected.
|
||
|
|
// Input : pszKey - Name of key to select.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::SetCurKey(LPCTSTR pszKey)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::SetCurKey", "Object Properties" );
|
||
|
|
|
||
|
|
int nSel = m_VarList.GetItemCount();
|
||
|
|
|
||
|
|
for (int i = 0; i < nSel; i++)
|
||
|
|
{
|
||
|
|
CString str = (CString)(const char*)m_VarList.GetItemData( i );
|
||
|
|
if ( !Q_stricmp( str, pszKey ) )
|
||
|
|
{
|
||
|
|
// found it here -
|
||
|
|
SetCurVarListSelection( i );
|
||
|
|
|
||
|
|
// FIXME: Ideally we'd only call OnSelChangeKeyvalues if the selection index
|
||
|
|
// actually changed, but that makes the keyvalue text not refresh properly
|
||
|
|
// when multiselecting entities with a sidelist key selected.
|
||
|
|
if ( m_bSmartedit )
|
||
|
|
{
|
||
|
|
OnSelchangeKeyvalues();
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Not found, select the first key in the list.
|
||
|
|
//
|
||
|
|
SetCurVarListSelection( 0 );
|
||
|
|
OnSelchangeKeyvalues();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::DestroySmartControls(void)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::DestroySmartControls", "Object Properties" );
|
||
|
|
|
||
|
|
for (int i = 0; i < m_SmartControls.Count(); i++)
|
||
|
|
{
|
||
|
|
CWnd *pControl = m_SmartControls.Element(i);
|
||
|
|
if (pControl != NULL)
|
||
|
|
{
|
||
|
|
pControl->DestroyWindow();
|
||
|
|
delete pControl;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_SmartControls.RemoveAll();
|
||
|
|
m_pSmartBrowseButton = NULL;
|
||
|
|
m_pSmartControl = NULL;
|
||
|
|
m_pLastSmartControlVar = NULL;
|
||
|
|
|
||
|
|
m_pEditInstanceVariable = NULL;
|
||
|
|
m_pEditInstanceValue = NULL;
|
||
|
|
m_pComboInstanceParmType = NULL;
|
||
|
|
|
||
|
|
UpdateAnchors();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Creates the smart controls based on the given type. Deletes any
|
||
|
|
// smart controls that are not appropriate to the given type.
|
||
|
|
// Input : eType - Type of keyvalue for which to create controls.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::CreateSmartControls(GDinputvariable *pVar, CUtlVector<const char *>*pHelperType)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::CreateSmartControls", "Object Properties" );
|
||
|
|
|
||
|
|
// dvs: TODO: break this monster up into smaller functions
|
||
|
|
if (pVar == NULL)
|
||
|
|
{
|
||
|
|
// UNDONE: delete smart controls?
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
CString strValue = m_kv.GetValue( pVar->GetName() );
|
||
|
|
|
||
|
|
// If this is the same var that our smart controls are already setup for, then don't do anything.
|
||
|
|
if ( m_SmartControls.Count() > 0 &&
|
||
|
|
pVar == m_pLastSmartControlVar &&
|
||
|
|
Q_stricmp( strValue, m_LastSmartControlVarValue ) == 0 )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Set this so that we don't process notifications when we set the edit text,
|
||
|
|
// which makes us do things like assume the user changed a key when they didn't.
|
||
|
|
//
|
||
|
|
m_bIgnoreKVChange = true;
|
||
|
|
|
||
|
|
DestroySmartControls();
|
||
|
|
m_pLastSmartControlVar = pVar;
|
||
|
|
m_LastSmartControlVarValue = strValue;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Build a rectangle in which to create a new control.
|
||
|
|
//
|
||
|
|
CRect ctrlrect = CalculateSmartControlRect();
|
||
|
|
|
||
|
|
GDIV_TYPE eType = pVar->GetType();
|
||
|
|
|
||
|
|
//
|
||
|
|
// Hide or show color button.
|
||
|
|
//
|
||
|
|
m_cPickColor.ShowWindow((eType == ivColor255 || eType == ivColor1) ? SW_SHOW : SW_HIDE);
|
||
|
|
|
||
|
|
HFONT hControlFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
|
||
|
|
if (hControlFont == NULL)
|
||
|
|
{
|
||
|
|
hControlFont = (HFONT)GetStockObject(ANSI_VAR_FONT);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Hide or show the Smart angles controls.
|
||
|
|
//
|
||
|
|
bool bShowSmartAngles = false;
|
||
|
|
if (eType == ivAngle)
|
||
|
|
{
|
||
|
|
CreateSmartControls_Angle( pVar, ctrlrect, hControlFont, &bShowSmartAngles );
|
||
|
|
}
|
||
|
|
|
||
|
|
m_SmartAngle.ShowWindow(bShowSmartAngles ? SW_SHOW : SW_HIDE);
|
||
|
|
m_SmartAngleEdit.ShowWindow(bShowSmartAngles ? SW_SHOW : SW_HIDE);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Choices, NPC classes and filter classes get a combo box.
|
||
|
|
//
|
||
|
|
if ((eType == ivChoices) || (eType == ivNPCClass) || (eType == ivFilterClass) || (eType == ivPointEntityClass) )
|
||
|
|
{
|
||
|
|
CreateSmartControls_Choices( pVar, ctrlrect, hControlFont );
|
||
|
|
}
|
||
|
|
else if ( eType == ivInstanceVariable )
|
||
|
|
{
|
||
|
|
CreateSmartControls_InstanceVariable( pVar, ctrlrect, hControlFont );
|
||
|
|
}
|
||
|
|
else if ( eType == ivInstanceParm )
|
||
|
|
{
|
||
|
|
CreateSmartControls_InstanceParm( pVar, ctrlrect, hControlFont );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if ((eType == ivTargetSrc) || (eType == ivTargetDest))
|
||
|
|
{
|
||
|
|
CreateSmartControls_TargetName( pVar, ctrlrect, hControlFont );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
CreateSmartControls_BasicEditControl( pVar, ctrlrect, hControlFont, pHelperType );
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create a "Browse..." button for browsing for files.
|
||
|
|
//
|
||
|
|
if ((eType == ivStudioModel) || (eType == ivSprite) || (eType == ivSound) || (eType == ivDecal) ||
|
||
|
|
(eType == ivMaterial) || (eType == ivScene) || ( eType == ivInstanceFile ) )
|
||
|
|
{
|
||
|
|
CreateSmartControls_BrowseAndPlayButtons( pVar, ctrlrect, hControlFont );
|
||
|
|
}
|
||
|
|
else if ((eType == ivTargetDest) || (eType == ivTargetNameOrClass) || (eType == ivTargetSrc) || (eType == ivNodeDest))
|
||
|
|
{
|
||
|
|
CreateSmartControls_MarkAndEyedropperButtons( pVar, ctrlrect, hControlFont );
|
||
|
|
}
|
||
|
|
else if ((eType == ivSide) || (eType == ivSideList))
|
||
|
|
{
|
||
|
|
CreateSmartControls_PickButton( pVar, ctrlrect, hControlFont );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pSmartControl->ShowWindow(SW_SHOW);
|
||
|
|
m_pSmartControl->SetWindowPos(&m_VarList, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOREDRAW | SWP_NOSIZE);
|
||
|
|
|
||
|
|
m_bIgnoreKVChange = false;
|
||
|
|
UpdateAnchors();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
CRect COP_Entity::CalculateSmartControlRect()
|
||
|
|
{
|
||
|
|
CRect ctrlrect;
|
||
|
|
|
||
|
|
GetDlgItem(IDC_KEY)->GetWindowRect(ctrlrect);
|
||
|
|
ScreenToClient(ctrlrect);
|
||
|
|
int nHeight = ctrlrect.Height();
|
||
|
|
int nRight = ctrlrect.right - 10;
|
||
|
|
|
||
|
|
// Put it just to the right of the keyvalue list.
|
||
|
|
m_VarList.GetWindowRect(ctrlrect);
|
||
|
|
ScreenToClient(ctrlrect);
|
||
|
|
|
||
|
|
ctrlrect.left = ctrlrect.right + 10;
|
||
|
|
ctrlrect.right = nRight;
|
||
|
|
ctrlrect.bottom = ctrlrect.top + nHeight;
|
||
|
|
|
||
|
|
return ctrlrect;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::CreateSmartControls_Angle( GDinputvariable *pVar, CRect &ctrlrect, HFONT hControlFont, bool *bShowSmartAngles )
|
||
|
|
{
|
||
|
|
if (stricmp(pVar->GetName(), "angles"))
|
||
|
|
{
|
||
|
|
*bShowSmartAngles = true;
|
||
|
|
|
||
|
|
CRect rectAngleBox;
|
||
|
|
m_SmartAngle.GetWindowRect(&rectAngleBox);
|
||
|
|
|
||
|
|
CRect rectAngleEdit;
|
||
|
|
m_SmartAngleEdit.GetWindowRect(&rectAngleEdit);
|
||
|
|
|
||
|
|
m_SmartAngle.SetWindowPos(NULL, ctrlrect.left + rectAngleEdit.Width() + 4, ctrlrect.bottom + 10, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
|
||
|
|
m_SmartAngleEdit.SetWindowPos(NULL, ctrlrect.left, (ctrlrect.bottom + rectAngleBox.Height() + 10) - rectAngleEdit.Height(), 0, 0, SWP_NOSIZE | SWP_NOZORDER);
|
||
|
|
|
||
|
|
// Update the smart control with the current value
|
||
|
|
LPCTSTR pszValue = m_kv.GetValue(pVar->GetName());
|
||
|
|
if (pszValue != NULL)
|
||
|
|
{
|
||
|
|
if (!stricmp(pszValue, VALUE_DIFFERENT_STRING))
|
||
|
|
{
|
||
|
|
m_SmartAngle.SetDifferent(true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_SmartAngle.SetDifferent(false);
|
||
|
|
m_SmartAngle.SetAngles(pszValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create an eyedropper button for picking target angles.
|
||
|
|
//
|
||
|
|
CRect ButtonRect;
|
||
|
|
if (bShowSmartAngles)
|
||
|
|
{
|
||
|
|
CRect rectAngleBox;
|
||
|
|
m_SmartAngle.GetWindowRect(&rectAngleBox);
|
||
|
|
ScreenToClient(&rectAngleBox);
|
||
|
|
|
||
|
|
CRect rectAngleEdit;
|
||
|
|
m_SmartAngleEdit.GetWindowRect(&rectAngleEdit);
|
||
|
|
ScreenToClient(&rectAngleEdit);
|
||
|
|
|
||
|
|
ButtonRect.left = rectAngleBox.right + 8;
|
||
|
|
ButtonRect.top = rectAngleEdit.top;
|
||
|
|
ButtonRect.bottom = rectAngleEdit.bottom;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ButtonRect.left = ctrlrect.left;
|
||
|
|
ButtonRect.top = ctrlrect.bottom + 4;
|
||
|
|
ButtonRect.bottom = ButtonRect.top + ctrlrect.Height();
|
||
|
|
}
|
||
|
|
|
||
|
|
CButton *pButton = new CButton;
|
||
|
|
pButton->CreateEx(0, "Button", "Point At...", WS_TABSTOP | WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | BS_PUSHLIKE,
|
||
|
|
ButtonRect.left, ButtonRect.top, 58, ButtonRect.Height() + 2, GetSafeHwnd(), (HMENU)IDC_PICK_ANGLES);
|
||
|
|
pButton->SendMessage(WM_SETFONT, (WPARAM)hControlFont);
|
||
|
|
|
||
|
|
CWinApp *pApp = AfxGetApp();
|
||
|
|
HICON hIcon = pApp->LoadIcon(IDI_CROSSHAIR);
|
||
|
|
pButton->SetIcon(hIcon);
|
||
|
|
|
||
|
|
m_SmartControls.AddToTail(pButton);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::CreateSmartControls_Choices( GDinputvariable *pVar, CRect &ctrlrect, HFONT hControlFont )
|
||
|
|
{
|
||
|
|
CMyComboBox *pCombo = new CMyComboBox;
|
||
|
|
pCombo->SetParentPage(this);
|
||
|
|
ctrlrect.bottom += 150;
|
||
|
|
pCombo->Create(CBS_DROPDOWN | CBS_HASSTRINGS | WS_TABSTOP | WS_CHILD | WS_BORDER | WS_VSCROLL | CBS_AUTOHSCROLL | ((pVar->GetType() != ivChoices) ? CBS_SORT : 0), ctrlrect, this, IDC_SMARTCONTROL);
|
||
|
|
pCombo->SendMessage(WM_SETFONT, (WPARAM)hControlFont);
|
||
|
|
pCombo->SetDroppedWidth(150);
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are editing multiple entities, start with the "(different)" string.
|
||
|
|
//
|
||
|
|
if (IsMultiEdit())
|
||
|
|
{
|
||
|
|
pCombo->AddString(VALUE_DIFFERENT_STRING);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If this is a choices field, give combo box text choices from GameData variable
|
||
|
|
//
|
||
|
|
if (pVar->GetType() == ivChoices)
|
||
|
|
{
|
||
|
|
for (int i = 0; i < pVar->GetChoiceCount(); i++)
|
||
|
|
{
|
||
|
|
pCombo->AddString(pVar->GetChoiceCaption(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//
|
||
|
|
// For filterclass display a list of all the names of filters that are in the map
|
||
|
|
//
|
||
|
|
else if (pVar->GetType() == ivFilterClass)
|
||
|
|
{
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
CMapWorld *pWorld = pDoc->GetMapWorld();
|
||
|
|
const CMapEntityList *pEntityList = pWorld->EntityList_GetList();
|
||
|
|
|
||
|
|
|
||
|
|
FOR_EACH_OBJ( *pEntityList, pos )
|
||
|
|
{
|
||
|
|
CMapEntity *pEntity = pEntityList->Element(pos);
|
||
|
|
GDclass *pClass = pEntity->GetClass();
|
||
|
|
if (pClass && pClass->IsFilterClass())
|
||
|
|
{
|
||
|
|
const char *pString = pEntity->GetKeyValue("targetname");
|
||
|
|
if (pString)
|
||
|
|
{
|
||
|
|
pCombo->AddString(pString);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//
|
||
|
|
// For npcclass fields, fill with all the NPC classes from the FGD.
|
||
|
|
//
|
||
|
|
else if (pVar->GetType() == ivNPCClass)
|
||
|
|
{
|
||
|
|
if (pGD != NULL)
|
||
|
|
{
|
||
|
|
int nCount = pGD->GetClassCount();
|
||
|
|
for (int i = 0; i < nCount; i++)
|
||
|
|
{
|
||
|
|
GDclass *pClass = pGD->GetClass(i);
|
||
|
|
if (pClass->IsNPCClass())
|
||
|
|
{
|
||
|
|
pCombo->AddString(pClass->GetName());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//
|
||
|
|
// For pointentity fields, fill with all the point entity classes from the FGD.
|
||
|
|
//
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (pGD != NULL)
|
||
|
|
{
|
||
|
|
int nCount = pGD->GetClassCount();
|
||
|
|
for (int i = 0; i < nCount; i++)
|
||
|
|
{
|
||
|
|
GDclass *pClass = pGD->GetClass(i);
|
||
|
|
if (pClass->IsPointClass())
|
||
|
|
{
|
||
|
|
pCombo->AddString(pClass->GetName());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If the current value is the "different" string, display that in the combo box.
|
||
|
|
//
|
||
|
|
LPCTSTR pszValue = m_kv.GetValue(pVar->GetName());
|
||
|
|
if (pszValue != NULL)
|
||
|
|
{
|
||
|
|
if (strcmp(pszValue, VALUE_DIFFERENT_STRING) == 0)
|
||
|
|
{
|
||
|
|
pCombo->SelectString(-1, VALUE_DIFFERENT_STRING);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
const char *p = NULL;
|
||
|
|
|
||
|
|
//
|
||
|
|
// If this is a choices field and the current value corresponds to one of our
|
||
|
|
// choices, display the friendly name of the choice in the edit control.
|
||
|
|
//
|
||
|
|
if (pVar->GetType() == ivChoices)
|
||
|
|
{
|
||
|
|
p = pVar->ItemStringForValue(pszValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (p != NULL)
|
||
|
|
{
|
||
|
|
pCombo->SelectString(-1, p);
|
||
|
|
}
|
||
|
|
//
|
||
|
|
// Otherwise, just display the value as-is.
|
||
|
|
//
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pCombo->SetWindowText(pszValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pSmartControl = pCombo;
|
||
|
|
m_SmartControls.AddToTail(pCombo);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::CreateSmartControls_TargetName( GDinputvariable *pVar, CRect &ctrlrect, HFONT hControlFont )
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Create a combo box for picking target names.
|
||
|
|
//
|
||
|
|
CRect ComboRect = ctrlrect;
|
||
|
|
ComboRect.bottom += 150;
|
||
|
|
CTargetNameComboBox *pCombo = CTargetNameComboBox::Create( &m_SmartControlTargetNameRouter, CBS_DROPDOWN | WS_TABSTOP | WS_CHILD | WS_BORDER | CBS_AUTOHSCROLL | WS_VSCROLL | CBS_SORT, ComboRect, this, IDC_SMARTCONTROL_TARGETNAME);
|
||
|
|
pCombo->SendMessage(WM_SETFONT, (WPARAM)hControlFont);
|
||
|
|
pCombo->SetDroppedWidth(150);
|
||
|
|
|
||
|
|
m_pSmartControl = pCombo;
|
||
|
|
m_SmartControls.AddToTail(m_pSmartControl);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Attach the world's entity list to the add dialog.
|
||
|
|
//
|
||
|
|
// HACK: This is ugly. It should be passed in from outside.
|
||
|
|
//
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
CMapWorld *pWorld = pDoc->GetMapWorld();
|
||
|
|
pCombo->SetEntityList(pWorld->EntityList_GetList());
|
||
|
|
pCombo->SelectItem( m_kv.GetValue(pVar->GetName()) );
|
||
|
|
|
||
|
|
if (pVar->IsReadOnly())
|
||
|
|
{
|
||
|
|
pCombo->EnableWindow(FALSE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::CreateSmartControls_BasicEditControl( GDinputvariable *pVar, CRect &ctrlrect, HFONT hControlFont, CUtlVector<const char *> *pHelperType )
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Create an edit control for inputting the keyvalue as text.
|
||
|
|
//
|
||
|
|
CMyEdit *pEdit = new CMyEdit;
|
||
|
|
pEdit->SetParentPage(this);
|
||
|
|
ctrlrect.bottom += 2;
|
||
|
|
pEdit->CreateEx(WS_EX_CLIENTEDGE, "EDIT", "", WS_TABSTOP | WS_CHILD | WS_BORDER | ES_AUTOHSCROLL,
|
||
|
|
ctrlrect.left, ctrlrect.top, ctrlrect.Width(), ctrlrect.Height(), GetSafeHwnd(), HMENU(IDC_SMARTCONTROL));
|
||
|
|
pEdit->SendMessage(WM_SETFONT, (WPARAM)hControlFont);
|
||
|
|
|
||
|
|
const char *pValue = m_kv.GetValue( pVar->GetName() );
|
||
|
|
if ( pValue )
|
||
|
|
pEdit->SetWindowText( pValue );
|
||
|
|
|
||
|
|
if (pVar->IsReadOnly())
|
||
|
|
{
|
||
|
|
pEdit->EnableWindow(FALSE);
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < pHelperType->Count(); i++ )
|
||
|
|
{
|
||
|
|
if ( !Q_strcmp( pHelperType->Element(i), "sphere" ) )
|
||
|
|
{
|
||
|
|
CRect ButtonRect = ctrlrect;
|
||
|
|
ButtonRect.top = ctrlrect.bottom + 4;
|
||
|
|
ButtonRect.bottom = ctrlrect.bottom + ctrlrect.Height() + 4;
|
||
|
|
ButtonRect.right = ButtonRect.left + 32;
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
CMapView3D *pView = pDoc->GetFirst3DView();
|
||
|
|
int disabled = 0;
|
||
|
|
if ( !pView )
|
||
|
|
{
|
||
|
|
disabled = WS_DISABLED;
|
||
|
|
}
|
||
|
|
|
||
|
|
CButton *pButton = new CButton;
|
||
|
|
pButton->CreateEx(0, "Button", "", WS_TABSTOP | WS_CHILD | WS_VISIBLE | BS_ICON | BS_PUSHLIKE | disabled,
|
||
|
|
ButtonRect.left, ButtonRect.top, ButtonRect.Width(), ButtonRect.Height(),
|
||
|
|
GetSafeHwnd(), (HMENU)IDC_CAMERA_DISTANCE);
|
||
|
|
ButtonRect.left += ButtonRect.Width() + 4;
|
||
|
|
CWinApp *pApp = AfxGetApp();
|
||
|
|
HICON hIcon = pApp->LoadIcon(IDI_CAMERA);
|
||
|
|
pButton->SetIcon(hIcon);
|
||
|
|
|
||
|
|
m_SmartControls.AddToTail(pButton);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pSmartControl = pEdit;
|
||
|
|
m_SmartControls.AddToTail(pEdit);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::CreateSmartControls_BrowseAndPlayButtons( GDinputvariable *pVar, CRect &ctrlrect, HFONT hControlFont )
|
||
|
|
{
|
||
|
|
CRect ButtonRect = ctrlrect;
|
||
|
|
|
||
|
|
ButtonRect.top = ctrlrect.bottom + 4;
|
||
|
|
ButtonRect.bottom = ctrlrect.bottom + ctrlrect.Height() + 4;
|
||
|
|
ButtonRect.right = ButtonRect.left + 54;
|
||
|
|
|
||
|
|
HMENU message = (HMENU)IDC_BROWSE;
|
||
|
|
if ( pVar->GetType() == ivInstanceFile )
|
||
|
|
{
|
||
|
|
message = (HMENU)IDC_BROWSE_INSTANCE;
|
||
|
|
}
|
||
|
|
|
||
|
|
CButton *pButton = new CButton;
|
||
|
|
pButton->CreateEx(0, "Button", "Browse...", WS_TABSTOP | WS_CHILD | WS_VISIBLE,
|
||
|
|
ButtonRect.left, ButtonRect.top, ButtonRect.Width(), ButtonRect.Height(),
|
||
|
|
GetSafeHwnd(), message);
|
||
|
|
pButton->SendMessage(WM_SETFONT, (WPARAM)hControlFont);
|
||
|
|
m_pSmartBrowseButton = pButton;
|
||
|
|
|
||
|
|
m_SmartControls.AddToTail(pButton);
|
||
|
|
|
||
|
|
if ( pVar->GetType() == ivSound || pVar->GetType() == ivScene )
|
||
|
|
{
|
||
|
|
ButtonRect.left = ButtonRect.right + 8;
|
||
|
|
ButtonRect.right = ButtonRect.left + 54;
|
||
|
|
|
||
|
|
pButton = new CButton;
|
||
|
|
pButton->CreateEx(0, "Button", "Play", WS_TABSTOP | WS_CHILD | WS_VISIBLE,
|
||
|
|
ButtonRect.left, ButtonRect.top, ButtonRect.Width(), ButtonRect.Height(),
|
||
|
|
GetSafeHwnd(), (HMENU)IDC_PLAY_SOUND);
|
||
|
|
pButton->SendMessage(WM_SETFONT, (WPARAM)hControlFont);
|
||
|
|
|
||
|
|
m_SmartControls.AddToTail(pButton);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::CreateSmartControls_MarkAndEyedropperButtons( GDinputvariable *pVar, CRect &ctrlrect, HFONT hControlFont )
|
||
|
|
{
|
||
|
|
CRect ButtonRect = ctrlrect;
|
||
|
|
ButtonRect.top = ctrlrect.bottom + 4;
|
||
|
|
ButtonRect.bottom = ctrlrect.bottom + ctrlrect.Height() + 4;
|
||
|
|
CButton *pButton = NULL;
|
||
|
|
|
||
|
|
GDIV_TYPE eType = pVar->GetType();
|
||
|
|
|
||
|
|
if ((eType == ivTargetDest) || (eType == ivTargetNameOrClass) || (eType == ivTargetSrc))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Create a "Mark" button for finding target entities.
|
||
|
|
//
|
||
|
|
ButtonRect.right = ButtonRect.left + 48;
|
||
|
|
|
||
|
|
pButton = new CButton;
|
||
|
|
pButton->CreateEx(0, "Button", "Mark", WS_TABSTOP | WS_CHILD | WS_VISIBLE,
|
||
|
|
ButtonRect.left, ButtonRect.top, ButtonRect.Width(), ButtonRect.Height(),
|
||
|
|
GetSafeHwnd(), (HMENU)IDC_MARK);
|
||
|
|
pButton->SendMessage(WM_SETFONT, (WPARAM)hControlFont);
|
||
|
|
|
||
|
|
ButtonRect.left += ButtonRect.Width() + 4;
|
||
|
|
|
||
|
|
m_SmartControls.AddToTail(pButton);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create a "Mark+Add" button for finding target entities.
|
||
|
|
//
|
||
|
|
ButtonRect.right = ButtonRect.left + 64;
|
||
|
|
|
||
|
|
pButton = new CButton;
|
||
|
|
pButton->CreateEx(0, "Button", "Mark+Add", WS_TABSTOP | WS_CHILD | WS_VISIBLE,
|
||
|
|
ButtonRect.left, ButtonRect.top, ButtonRect.Width(), ButtonRect.Height(),
|
||
|
|
GetSafeHwnd(), (HMENU)IDC_MARK_AND_ADD);
|
||
|
|
pButton->SendMessage(WM_SETFONT, (WPARAM)hControlFont);
|
||
|
|
|
||
|
|
ButtonRect.left += ButtonRect.Width() + 4;
|
||
|
|
|
||
|
|
m_SmartControls.AddToTail(pButton);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Create an eyedropper button for picking entities.
|
||
|
|
//
|
||
|
|
ButtonRect.right = ButtonRect.left + 32;
|
||
|
|
|
||
|
|
pButton = new CButton;
|
||
|
|
pButton->CreateEx(0, "Button", "", WS_TABSTOP | WS_CHILD | WS_VISIBLE | BS_ICON | BS_AUTOCHECKBOX | BS_PUSHLIKE,
|
||
|
|
ButtonRect.left, ButtonRect.top, ButtonRect.Width(), ButtonRect.Height(),
|
||
|
|
GetSafeHwnd(), (HMENU)IDC_PICK_ENTITY);
|
||
|
|
|
||
|
|
ButtonRect.left += ButtonRect.Width() + 4;
|
||
|
|
|
||
|
|
CWinApp *pApp = AfxGetApp();
|
||
|
|
HICON hIcon = pApp->LoadIcon(IDI_EYEDROPPER);
|
||
|
|
pButton->SetIcon(hIcon);
|
||
|
|
|
||
|
|
m_SmartControls.AddToTail(pButton);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::CreateSmartControls_PickButton( GDinputvariable *pVar, CRect &ctrlrect, HFONT hControlFont )
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Create a "Pick" button for clicking on brush sides.
|
||
|
|
//
|
||
|
|
CRect ButtonRect = ctrlrect;
|
||
|
|
|
||
|
|
ButtonRect.top = ctrlrect.bottom + 4;
|
||
|
|
ButtonRect.bottom = ctrlrect.bottom + ctrlrect.Height() + 4;
|
||
|
|
ButtonRect.right = ButtonRect.left + 54;
|
||
|
|
|
||
|
|
CButton *pButton = new CButton;
|
||
|
|
pButton->CreateEx(0, "Button", "Pick...", WS_TABSTOP | WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | BS_PUSHLIKE,
|
||
|
|
ButtonRect.left, ButtonRect.top, ButtonRect.Width(), ButtonRect.Height(),
|
||
|
|
GetSafeHwnd(), (HMENU)IDC_PICK_FACES);
|
||
|
|
pButton->SendMessage(WM_SETFONT, (WPARAM)hControlFont);
|
||
|
|
|
||
|
|
m_SmartControls.AddToTail(pButton);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: this function will set up the smart controls for an instance variable
|
||
|
|
// Input : pVar - the kv pair
|
||
|
|
// ctrlrect - the rect space of this area
|
||
|
|
// hControlFont - the standard font
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::CreateSmartControls_InstanceVariable( GDinputvariable *pVar, CRect &ctrlrect, HFONT hControlFont )
|
||
|
|
{
|
||
|
|
const char *pValue = m_kv.GetValue( pVar->GetName() );
|
||
|
|
char ValueData[ KEYVALUE_MAX_KEY_LENGTH ];
|
||
|
|
const char *pVariable, *pReplace;
|
||
|
|
const int VariableLimit = 50;
|
||
|
|
|
||
|
|
pVariable = pReplace = "";
|
||
|
|
if ( pValue )
|
||
|
|
{
|
||
|
|
strcpy( ValueData, pValue );
|
||
|
|
pVariable = ValueData;
|
||
|
|
char *pos = strchr( ValueData, ' ' );
|
||
|
|
if ( pos )
|
||
|
|
{
|
||
|
|
*pos = 0;
|
||
|
|
pos++;
|
||
|
|
pReplace = pos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_pObjectList->Count() == 1 )
|
||
|
|
{
|
||
|
|
CMapEntity *pEntity = static_cast< CMapEntity * >( m_pObjectList->Element( 0 ) );
|
||
|
|
|
||
|
|
CMapInstance *pMapInstance = pEntity->GetChildOfType( ( CMapInstance * )NULL );
|
||
|
|
if ( pMapInstance != NULL && pMapInstance->GetInstancedMap() != NULL )
|
||
|
|
{
|
||
|
|
CMapEntityList entityList;
|
||
|
|
|
||
|
|
pMapInstance->GetInstancedMap()->FindEntitiesByClassName( entityList, "func_instance_parms", false );
|
||
|
|
if ( entityList.Count() == 1 )
|
||
|
|
{
|
||
|
|
CMapEntity *pInstanceParmsEntity = entityList.Element( 0 );
|
||
|
|
|
||
|
|
for ( int i = pInstanceParmsEntity->GetFirstKeyValue(); i != pInstanceParmsEntity->GetInvalidKeyValue(); i = pInstanceParmsEntity->GetNextKeyValue( i ) )
|
||
|
|
{
|
||
|
|
LPCTSTR pKey = pInstanceParmsEntity->GetKey( i );
|
||
|
|
LPCTSTR psValue = pInstanceParmsEntity->GetKeyValue( i );
|
||
|
|
|
||
|
|
if ( strnicmp( pKey, "parm", strlen( "parm" ) ) == 0 )
|
||
|
|
{
|
||
|
|
if ( strnicmp( psValue, pVariable, strlen( pVariable ) ) == 0 )
|
||
|
|
{
|
||
|
|
m_kv.SetValue( "temp_parm_value", pReplace );
|
||
|
|
m_kv.SetValue( "temp_parm_name", pVar->GetName() );
|
||
|
|
m_kv.SetValue( "temp_parm_field", pVariable );
|
||
|
|
|
||
|
|
m_pInstanceVar = new GDinputvariable( "color255", "temp_parm_value" );
|
||
|
|
CUtlVector<const char *>helperNames;
|
||
|
|
|
||
|
|
m_pDisplayClass->GetHelperForGDVar( m_pInstanceVar, &helperNames );
|
||
|
|
|
||
|
|
//
|
||
|
|
// Update the keyvalue help text control with this variable's help info.
|
||
|
|
//
|
||
|
|
m_KeyValueHelpText.SetWindowText(m_pInstanceVar->GetDescription());
|
||
|
|
|
||
|
|
CreateSmartControls(m_pInstanceVar, &helperNames);
|
||
|
|
m_eEditType = m_pInstanceVar->GetType();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CStatic *pStaticInstanceVariable;
|
||
|
|
pStaticInstanceVariable = new CStatic;
|
||
|
|
pStaticInstanceVariable->CreateEx( WS_EX_LEFT, "STATIC", "Variable:", WS_CHILD | WS_VISIBLE | SS_LEFT, ctrlrect.left, ctrlrect.top, 50, 24, GetSafeHwnd(), HMENU( IDC_STATIC ) );
|
||
|
|
pStaticInstanceVariable->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );
|
||
|
|
|
||
|
|
m_pEditInstanceVariable = new CEdit;
|
||
|
|
ctrlrect.bottom += 2;
|
||
|
|
m_pEditInstanceVariable->CreateEx( WS_EX_CLIENTEDGE, "EDIT", "", WS_TABSTOP | WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL,
|
||
|
|
ctrlrect.left + 50, ctrlrect.top, ctrlrect.Width() - 50, 24, GetSafeHwnd(), HMENU( IDC_SMARTCONTROL_INSTANCE_VARIABLE ) );
|
||
|
|
m_pEditInstanceVariable->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );
|
||
|
|
m_pEditInstanceVariable->SetWindowText( pVariable );
|
||
|
|
m_pEditInstanceVariable->SetLimitText( VariableLimit );
|
||
|
|
|
||
|
|
if ( pVar->IsReadOnly() )
|
||
|
|
{
|
||
|
|
m_pEditInstanceVariable->EnableWindow( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
ctrlrect.top += 26;
|
||
|
|
ctrlrect.bottom += 26;
|
||
|
|
|
||
|
|
CStatic *pStaticInstanceValue;
|
||
|
|
pStaticInstanceValue = new CStatic;
|
||
|
|
pStaticInstanceValue->CreateEx( WS_EX_LEFT, "STATIC", "Value:", WS_CHILD | WS_VISIBLE | SS_LEFT, ctrlrect.left, ctrlrect.top, 50, 24, GetSafeHwnd(), HMENU( IDC_STATIC ) );
|
||
|
|
pStaticInstanceValue->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );
|
||
|
|
|
||
|
|
m_pEditInstanceValue = new CEdit;
|
||
|
|
m_pEditInstanceValue->CreateEx( WS_EX_CLIENTEDGE, "EDIT", "", WS_TABSTOP | WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL,
|
||
|
|
ctrlrect.left + 50, ctrlrect.top, ctrlrect.Width() - 50, 24, GetSafeHwnd(), HMENU( IDC_SMARTCONTROL_INSTANCE_VALUE ) );
|
||
|
|
m_pEditInstanceValue->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );
|
||
|
|
m_pEditInstanceValue->SetWindowText( pReplace );
|
||
|
|
m_pEditInstanceVariable->SetLimitText( KEYVALUE_MAX_KEY_LENGTH - VariableLimit - 2 ); // to account for null and space in between
|
||
|
|
|
||
|
|
if ( pVar->IsReadOnly() )
|
||
|
|
{
|
||
|
|
m_pEditInstanceValue->EnableWindow( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pSmartControl = m_pEditInstanceVariable;
|
||
|
|
m_SmartControls.AddToTail( m_pEditInstanceVariable );
|
||
|
|
m_SmartControls.AddToTail( m_pEditInstanceValue );
|
||
|
|
m_SmartControls.AddToTail( pStaticInstanceVariable );
|
||
|
|
m_SmartControls.AddToTail( pStaticInstanceValue );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: this function will set up the smart controls for an instance parameter
|
||
|
|
// Input : pVar - the kv pair
|
||
|
|
// ctrlrect - the rect space of this area
|
||
|
|
// hControlFont - the standard font
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::CreateSmartControls_InstanceParm( GDinputvariable *pVar, CRect &ctrlrect, HFONT hControlFont )
|
||
|
|
{
|
||
|
|
const char *pValue = m_kv.GetValue( pVar->GetName() );
|
||
|
|
char ValueData[ KEYVALUE_MAX_KEY_LENGTH ];
|
||
|
|
const char *pVariable, *pType;
|
||
|
|
const int VariableLimit = 50;
|
||
|
|
|
||
|
|
pVariable = pType = "";
|
||
|
|
if ( pValue )
|
||
|
|
{
|
||
|
|
strcpy( ValueData, pValue );
|
||
|
|
pVariable = ValueData;
|
||
|
|
char *pos = strchr( ValueData, ' ' );
|
||
|
|
if ( pos )
|
||
|
|
{
|
||
|
|
*pos = 0;
|
||
|
|
pos++;
|
||
|
|
pType = pos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CStatic *pStaticInstanceVariable;
|
||
|
|
pStaticInstanceVariable = new CStatic;
|
||
|
|
pStaticInstanceVariable->CreateEx( WS_EX_LEFT, "STATIC", "Variable:", WS_CHILD | WS_VISIBLE | SS_LEFT, ctrlrect.left, ctrlrect.top, 50, 24, GetSafeHwnd(), HMENU( IDC_STATIC ) );
|
||
|
|
pStaticInstanceVariable->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );
|
||
|
|
|
||
|
|
m_pEditInstanceVariable = new CEdit;
|
||
|
|
ctrlrect.bottom += 2;
|
||
|
|
m_pEditInstanceVariable->CreateEx( WS_EX_CLIENTEDGE, "EDIT", "", WS_TABSTOP | WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL,
|
||
|
|
ctrlrect.left + 50, ctrlrect.top, ctrlrect.Width() - 50, 24, GetSafeHwnd(), HMENU( IDC_SMARTCONTROL_INSTANCE_PARM ) );
|
||
|
|
m_pEditInstanceVariable->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );
|
||
|
|
m_pEditInstanceVariable->SetWindowText( pVariable );
|
||
|
|
m_pEditInstanceVariable->SetLimitText( VariableLimit );
|
||
|
|
|
||
|
|
if ( pVar->IsReadOnly() )
|
||
|
|
{
|
||
|
|
m_pEditInstanceVariable->EnableWindow( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
ctrlrect.top += 26;
|
||
|
|
ctrlrect.bottom += 26;
|
||
|
|
|
||
|
|
CStatic *pStaticInstanceValue;
|
||
|
|
pStaticInstanceValue = new CStatic;
|
||
|
|
pStaticInstanceValue->CreateEx( WS_EX_LEFT, "STATIC", "Value:", WS_CHILD | WS_VISIBLE | SS_LEFT, ctrlrect.left, ctrlrect.top, 50, 24, GetSafeHwnd(), HMENU( IDC_STATIC ) );
|
||
|
|
pStaticInstanceValue->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );
|
||
|
|
|
||
|
|
m_pComboInstanceParmType = new CMyComboBox;
|
||
|
|
m_pComboInstanceParmType->SetParentPage( this );
|
||
|
|
ctrlrect.bottom += 150;
|
||
|
|
ctrlrect.left += 50;
|
||
|
|
m_pComboInstanceParmType->Create( CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_TABSTOP | WS_CHILD | WS_VISIBLE | WS_BORDER | WS_VSCROLL | CBS_AUTOHSCROLL | CBS_SORT, ctrlrect, this, IDC_SMARTCONTROL_INSTANCE_PARM );
|
||
|
|
m_pComboInstanceParmType->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );
|
||
|
|
m_pComboInstanceParmType->SetDroppedWidth( 150 );
|
||
|
|
|
||
|
|
if ( pVar->IsReadOnly() )
|
||
|
|
{
|
||
|
|
m_pComboInstanceParmType->EnableWindow( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
for( int i = 0; i < ivMax; i++ )
|
||
|
|
{
|
||
|
|
m_pComboInstanceParmType->AddString( GDinputvariable::GetVarTypeName( ( GDIV_TYPE )i ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pComboInstanceParmType->SelectString( -1, pType );
|
||
|
|
|
||
|
|
m_pSmartControl = m_pEditInstanceVariable;
|
||
|
|
m_SmartControls.AddToTail( m_pEditInstanceVariable );
|
||
|
|
m_SmartControls.AddToTail( m_pComboInstanceParmType );
|
||
|
|
m_SmartControls.AddToTail( pStaticInstanceVariable );
|
||
|
|
m_SmartControls.AddToTail( pStaticInstanceValue );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::SetSmartControlText(const char *pszText)
|
||
|
|
{
|
||
|
|
// dvs: HACK: the smart control should be completely self-contained, the dialog
|
||
|
|
// should only set the type of the edited variable, then just set & get text
|
||
|
|
CTargetNameComboBox *pCombo = dynamic_cast <CTargetNameComboBox *>(m_pSmartControl);
|
||
|
|
if (pCombo)
|
||
|
|
{
|
||
|
|
pCombo->SelectItem(pszText);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pSmartControl->SetWindowText(pszText);
|
||
|
|
}
|
||
|
|
|
||
|
|
// FIXME: this should be called automatically, but it isn't
|
||
|
|
OnChangeSmartcontrol();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnSelchangeKeyvalues(void)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::OnSelchangeKeyvalues", "Object Properties" );
|
||
|
|
|
||
|
|
//
|
||
|
|
// Load new selection's key/values into the key/value
|
||
|
|
// edit controls.
|
||
|
|
//
|
||
|
|
if (m_VarList.m_hWnd == NULL)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_bSmartedit)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Stop face or entity picking if we are doing so.
|
||
|
|
//
|
||
|
|
StopPicking();
|
||
|
|
}
|
||
|
|
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
if (iSel == LB_ERR)
|
||
|
|
{
|
||
|
|
if (!m_bSmartedit)
|
||
|
|
{
|
||
|
|
// No selection; clear our the key and value controls.
|
||
|
|
m_cKey.SetWindowText("");
|
||
|
|
m_cValue.SetWindowText("");
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!m_bSmartedit)
|
||
|
|
{
|
||
|
|
CString str, val;
|
||
|
|
str = m_VarList.GetItemText( iSel, 0 );
|
||
|
|
val = m_VarList.GetItemText( iSel, 1 );
|
||
|
|
|
||
|
|
//
|
||
|
|
// Set the edit control text, but ignore the notifications caused by that.
|
||
|
|
//
|
||
|
|
m_bIgnoreKVChange = true;
|
||
|
|
m_cKey.SetWindowText( str );
|
||
|
|
m_cValue.SetWindowText( val );
|
||
|
|
m_bChangingKeyName = false;
|
||
|
|
m_bIgnoreKVChange = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
GDinputvariable *pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL || !m_pDisplayClass )
|
||
|
|
{
|
||
|
|
// This is a var added in dumbedit mode.
|
||
|
|
DestroySmartControls();
|
||
|
|
m_KeyValueHelpText.SetWindowText( "" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
CUtlVector<const char *>helperNames;
|
||
|
|
|
||
|
|
m_pDisplayClass->GetHelperForGDVar( pVar, &helperNames );
|
||
|
|
|
||
|
|
//
|
||
|
|
// Update the keyvalue help text control with this variable's help info.
|
||
|
|
//
|
||
|
|
m_KeyValueHelpText.SetWindowText(pVar->GetDescription());
|
||
|
|
|
||
|
|
CreateSmartControls(pVar, &helperNames);
|
||
|
|
m_eEditType = pVar->GetType();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Used only in standard (non-SmartEdit) mode. Called when the contents
|
||
|
|
// of the value edit control change. This is where the edit control
|
||
|
|
// contents are converted to keyvalue data in standard mode.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnChangeKeyorValue(void)
|
||
|
|
{
|
||
|
|
if (m_bIgnoreKVChange)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
if (iSel == LB_ERR)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
char szKey[KEYVALUE_MAX_KEY_LENGTH];
|
||
|
|
char szValue[KEYVALUE_MAX_VALUE_LENGTH];
|
||
|
|
|
||
|
|
m_cKey.GetWindowText(szKey, sizeof(szKey));
|
||
|
|
m_cValue.GetWindowText(szValue, sizeof(szValue));
|
||
|
|
|
||
|
|
UpdateKeyValue(szKey, szValue);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Save it in our local kv storage.
|
||
|
|
//
|
||
|
|
m_kv.SetValue(szKey, szValue);
|
||
|
|
|
||
|
|
// If they changed spawnflags, notify the flags page so its changes don't overwrite ours later.
|
||
|
|
if ( V_stricmp( szKey, SPAWNFLAGS_KEYNAME ) == 0 )
|
||
|
|
{
|
||
|
|
unsigned long value;
|
||
|
|
sscanf( szValue, "%lu", &value );
|
||
|
|
m_pFlagsPage->OnUpdateSpawnFlags( value );
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_bEnableControlUpdate)
|
||
|
|
{
|
||
|
|
// Update any controls that are displaying the same data as the edit control.
|
||
|
|
|
||
|
|
// This code should only be hit as a result of user input in the edit control!
|
||
|
|
// If they changed the "angles" key, update the main angles control.
|
||
|
|
if (!stricmp(szKey, "angles"))
|
||
|
|
{
|
||
|
|
m_Angle.SetDifferent(false);
|
||
|
|
m_Angle.SetAngles(szValue, true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnAddkeyvalue(void)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::OnAddkeyvalue", "Object Properties" );
|
||
|
|
|
||
|
|
// create a new keyvalue at the end of the list
|
||
|
|
CNewKeyValue newkv;
|
||
|
|
newkv.m_Key.Format("newkey%d", m_nNewKeyCount++);
|
||
|
|
newkv.m_Value = "value";
|
||
|
|
if(newkv.DoModal() == IDCANCEL)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// if the key we're adding is already in the list, do some
|
||
|
|
// stuff to make it unique
|
||
|
|
if(m_kv.GetValue(newkv.m_Key))
|
||
|
|
{
|
||
|
|
CString strTemp;
|
||
|
|
for(int i = 1; ; i++)
|
||
|
|
{
|
||
|
|
strTemp.Format("%s#%d", newkv.m_Key.GetBuffer(), i);
|
||
|
|
if(!m_kv.GetValue(strTemp))
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
newkv.m_Key = strTemp;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_kvAdded.SetValue( newkv.m_Key, "1" );
|
||
|
|
m_kv.SetValue( newkv.m_Key, newkv.m_Value );
|
||
|
|
|
||
|
|
PresentProperties();
|
||
|
|
SetCurKey( newkv.m_Key );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Deletes the selected keyvalue.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnRemovekeyvalue(void)
|
||
|
|
{
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
if (iSel == LB_ERR)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
CString strBuf;
|
||
|
|
strBuf = (CString)(const char*)m_VarList.GetItemData(iSel);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Remove the keyvalue from local storage.
|
||
|
|
//
|
||
|
|
m_kv.RemoveKey( strBuf );
|
||
|
|
m_VarList.DeleteItem(iSel);
|
||
|
|
if (iSel == m_VarList.GetItemCount())
|
||
|
|
{
|
||
|
|
SetCurVarListSelection( iSel - 1 );
|
||
|
|
}
|
||
|
|
|
||
|
|
ResortItems();
|
||
|
|
OnSelchangeKeyvalues();
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Returns a mask indicating which flags have the same caption and bit value
|
||
|
|
// between the two classes.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
static unsigned long GetMatchingFlagsMask( GDinputvariable *pVar1, GDinputvariable *pVar2 )
|
||
|
|
{
|
||
|
|
unsigned long nMatchingMask = 0;
|
||
|
|
|
||
|
|
for ( int i=0; i < pVar1->GetFlagCount(); i++ )
|
||
|
|
{
|
||
|
|
for ( int j=0; j < pVar2->GetFlagCount(); j++ )
|
||
|
|
{
|
||
|
|
if ( pVar1->GetFlagMask( i ) == pVar2->GetFlagMask( j ) )
|
||
|
|
{
|
||
|
|
if ( V_stricmp( pVar1->GetFlagCaption( i ), pVar2->GetFlagCaption( j ) ) == 0 )
|
||
|
|
{
|
||
|
|
unsigned long iMask = (unsigned long)pVar1->GetFlagMask( i );
|
||
|
|
nMatchingMask |= iMask;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return nMatchingMask;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Assign default values to keys that are in the FGD but missing from the entity.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::AssignClassDefaults(GDclass *pClass, GDclass *pOldClass)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::AssignClassDefaults", "Object Properties" );
|
||
|
|
|
||
|
|
if (!pClass)
|
||
|
|
return;
|
||
|
|
|
||
|
|
for (int i = 0; i < pClass->GetVariableCount(); i++)
|
||
|
|
{
|
||
|
|
GDinputvariable *pVar = pClass->GetVariableAt(i);
|
||
|
|
|
||
|
|
int iIndex;
|
||
|
|
LPCTSTR p = m_kv.GetValue(pVar->GetName(), &iIndex);
|
||
|
|
|
||
|
|
// Always reset spawnflags.
|
||
|
|
if (!strcmpi(pVar->GetName(), SPAWNFLAGS_KEYNAME))
|
||
|
|
{
|
||
|
|
unsigned long nOriginalFlagsValue = 0;
|
||
|
|
if (p)
|
||
|
|
{
|
||
|
|
sscanf( p, "%lu", &nOriginalFlagsValue );
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned long nCurrent = nOriginalFlagsValue;
|
||
|
|
if ( pOldClass && (pOldClass != pClass) )
|
||
|
|
{
|
||
|
|
// First, just use the defaults for the new class.
|
||
|
|
int defaultValue;
|
||
|
|
pVar->GetDefault( &defaultValue );
|
||
|
|
nCurrent = (unsigned long)defaultValue;
|
||
|
|
|
||
|
|
// But.. if the old class and the new class have any flags with the same name and value,
|
||
|
|
// then keep the current value for that flag.
|
||
|
|
GDinputvariable *pOldVar = pOldClass->VarForName( SPAWNFLAGS_KEYNAME );
|
||
|
|
if ( p && pOldVar )
|
||
|
|
{
|
||
|
|
unsigned long mask = GetMatchingFlagsMask( pOldVar, pVar );
|
||
|
|
nCurrent &= ~mask; // Get rid of the default value.
|
||
|
|
nCurrent |= (nOriginalFlagsValue & mask); // Add back in the current values.
|
||
|
|
}
|
||
|
|
|
||
|
|
// Notify the flags page so it'll have the right data if they tab to it.
|
||
|
|
// It'll also SAVE the right data when they save.
|
||
|
|
m_pFlagsPage->OnUpdateSpawnFlags( nCurrent );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
unsigned long nMask = 0;
|
||
|
|
int nCount = pVar->GetFlagCount();
|
||
|
|
for (int j = 0; j < nCount; j++)
|
||
|
|
{
|
||
|
|
nMask |= (unsigned int)pVar->GetFlagMask(j);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Mask off any bits that aren't defined in the FGD.
|
||
|
|
nCurrent &= nMask;
|
||
|
|
}
|
||
|
|
|
||
|
|
char szValue[128];
|
||
|
|
Q_snprintf( szValue, sizeof( szValue ), "%lu", nCurrent );
|
||
|
|
|
||
|
|
// Remember that we added or changed this key.
|
||
|
|
if (!p || Q_stricmp(p, szValue) != 0)
|
||
|
|
{
|
||
|
|
m_kvAdded.SetValue(SPAWNFLAGS_KEYNAME, "1");
|
||
|
|
}
|
||
|
|
|
||
|
|
m_kv.SetValue(SPAWNFLAGS_KEYNAME, szValue);
|
||
|
|
}
|
||
|
|
else if (!p)
|
||
|
|
{
|
||
|
|
MDkeyvalue newkv;
|
||
|
|
pVar->ResetDefaults();
|
||
|
|
pVar->ToKeyValue(&newkv);
|
||
|
|
m_kv.SetValue(newkv.szKey, newkv.szValue);
|
||
|
|
|
||
|
|
// Remember that we added this key.
|
||
|
|
m_kvAdded.SetValue(newkv.szKey, "1");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Updates the dialog based on a change to the entity class name.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::UpdateEditClass(const char *pszClass, bool bForce)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::UpdateClass", "Object Properties" );
|
||
|
|
|
||
|
|
GDclass *pOldEditClass = m_pEditClass;
|
||
|
|
m_pEditClass = pGD->ClassForName(pszClass);
|
||
|
|
|
||
|
|
if (!bForce && (m_pEditClass == pOldEditClass))
|
||
|
|
return;
|
||
|
|
|
||
|
|
//DBG("UpdateEditClass - BEFORE PRUNE\n");
|
||
|
|
//DumpKeyvalues(m_kv);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Remove unused keyvalues.
|
||
|
|
//
|
||
|
|
if (m_pEditClass != pOldEditClass && m_pEditClass && pOldEditClass && strcmpi(pszClass, "multi_manager"))
|
||
|
|
{
|
||
|
|
int iNext;
|
||
|
|
for ( int i=m_kv.GetFirst(); i != m_kv.GetInvalidIndex(); i=iNext )
|
||
|
|
{
|
||
|
|
iNext = m_kv.GetNext( i );
|
||
|
|
|
||
|
|
MDkeyvalue &KeyValue = m_kv.GetKeyValue(i);
|
||
|
|
if (m_pEditClass->VarForName(KeyValue.szKey) == NULL)
|
||
|
|
{
|
||
|
|
m_kv.RemoveKey(KeyValue.szKey);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//DBG("UpdateEditClass - AFTER PRUNE\n");
|
||
|
|
//DumpKeyvalues(m_kv);
|
||
|
|
|
||
|
|
AssignClassDefaults(m_pEditClass, pOldEditClass);
|
||
|
|
PresentProperties();
|
||
|
|
|
||
|
|
SetReadOnly( ( m_pDisplayClass != m_pEditClass ) || ( m_bCanEdit == false ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Called when a keyvalue is modified by the user.
|
||
|
|
// Input : szKey - The key name.
|
||
|
|
// szValue - The new value.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::UpdateKeyValue(const char *szKey, const char *szValue)
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::UpdateKeyValue", "Object Properties" );
|
||
|
|
|
||
|
|
m_kvAdded.SetValue(szKey, "1");
|
||
|
|
m_kv.SetValue(szKey, szValue);
|
||
|
|
|
||
|
|
int index = m_InstanceParmData.Find( szKey );
|
||
|
|
|
||
|
|
if ( index != m_InstanceParmData.InvalidIndex() )
|
||
|
|
{
|
||
|
|
CString NewValue = m_InstanceParmData[ index ].m_VariableName + " " + szValue;
|
||
|
|
|
||
|
|
m_kvAdded.SetValue( m_InstanceParmData[ index ].m_ParmKey, "1" );
|
||
|
|
m_kv.SetValue( m_InstanceParmData[ index ].m_ParmKey, NewValue );
|
||
|
|
RefreshKVListValues( m_InstanceParmData[ index ].m_ParmKey );
|
||
|
|
}
|
||
|
|
|
||
|
|
RefreshKVListValues( szKey );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Enables or disables SmartEdit mode, hiding showing the appropriate
|
||
|
|
// dialog controls.
|
||
|
|
// Input : b - TRUE to enable, FALSE to disable SmartEdit.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::SetSmartedit(bool bSet)
|
||
|
|
{
|
||
|
|
// Nothing to do?
|
||
|
|
if ( m_bSmartedit == bSet )
|
||
|
|
return;
|
||
|
|
|
||
|
|
m_bSmartedit = bSet;
|
||
|
|
|
||
|
|
//
|
||
|
|
// If disabling smartedit, remove any smartedit-specific controls that may
|
||
|
|
// or may not be currently visible.
|
||
|
|
//
|
||
|
|
if (!m_bSmartedit)
|
||
|
|
{
|
||
|
|
m_cPickColor.ShowWindow(SW_HIDE);
|
||
|
|
m_SmartAngle.ShowWindow(SW_HIDE);
|
||
|
|
m_SmartAngleEdit.ShowWindow(SW_HIDE);
|
||
|
|
|
||
|
|
DestroySmartControls();
|
||
|
|
}
|
||
|
|
|
||
|
|
m_KeyValueHelpText.ShowWindow(m_bSmartedit ? SW_SHOW : SW_HIDE);
|
||
|
|
GetDlgItem(IDC_KEYVALUE_HELP_GROUP)->ShowWindow(m_bSmartedit ? SW_SHOW : SW_HIDE);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Hide or show all controls after and including "delete kv" button.
|
||
|
|
//
|
||
|
|
for (int i = 0; i < ARRAYSIZE(g_DumbEditControls); i++)
|
||
|
|
{
|
||
|
|
CWnd *pWnd = GetDlgItem(g_DumbEditControls[i]);
|
||
|
|
if ( pWnd )
|
||
|
|
pWnd->ShowWindow(m_bSmartedit ? SW_HIDE : SW_SHOW);
|
||
|
|
}
|
||
|
|
|
||
|
|
((CButton*)GetDlgItem(IDC_SMARTEDIT))->SetCheck(m_bSmartedit);
|
||
|
|
|
||
|
|
PresentProperties();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::SetReadOnly(bool bReadOnly)
|
||
|
|
{
|
||
|
|
m_VarList.EnableWindow(bReadOnly ? FALSE : TRUE);
|
||
|
|
m_cPickColor.EnableWindow(bReadOnly ? FALSE : TRUE);
|
||
|
|
m_SmartAngle.EnableWindow(bReadOnly ? FALSE : TRUE);
|
||
|
|
m_SmartAngleEdit.EnableWindow(bReadOnly ? FALSE : TRUE);
|
||
|
|
m_PasteControl.EnableWindow(bReadOnly ? FALSE : TRUE);
|
||
|
|
|
||
|
|
m_KeyValueHelpText.EnableWindow(bReadOnly ? FALSE : TRUE);
|
||
|
|
GetDlgItem(IDC_KEYVALUE_HELP_GROUP)->EnableWindow(bReadOnly ? FALSE : TRUE);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Hide or show all controls after and including "delete kv" button.
|
||
|
|
//
|
||
|
|
for (int i = 0; i < ARRAYSIZE(g_DumbEditControls); i++)
|
||
|
|
{
|
||
|
|
CWnd *pWnd = GetDlgItem(g_DumbEditControls[i]);
|
||
|
|
if ( pWnd )
|
||
|
|
pWnd->EnableWindow( !bReadOnly );
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = 0; i < m_SmartControls.Count(); i++)
|
||
|
|
{
|
||
|
|
if (m_SmartControls.Element(i) != NULL)
|
||
|
|
{
|
||
|
|
m_SmartControls.Element(i)->EnableWindow(bReadOnly ? FALSE : TRUE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnSmartedit(void)
|
||
|
|
{
|
||
|
|
m_iSortColumn = -1; // Go back to FGD sorting.
|
||
|
|
SetSmartedit(!m_bSmartedit);
|
||
|
|
m_bWantSmartedit = m_bSmartedit;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Updates the UI to show properties for the given FGD class. If the class
|
||
|
|
// differs from the actual class of the edited objects, the UI is set to be
|
||
|
|
// read only until the Apply button is pressed.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::UpdateDisplayClass(const char *szClass)
|
||
|
|
{
|
||
|
|
UpdateDisplayClass( pGD->ClassForName( szClass ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
void COP_Entity::UpdateDisplayClass(GDclass *pClass)
|
||
|
|
{
|
||
|
|
// The outer check here is lame, but somewhere along the line, all the controls get enabled
|
||
|
|
// behind our backs. So verify that our state information is sane. If it's not, then we'll redo some state in here.
|
||
|
|
bool bForceRefresh = false;
|
||
|
|
if ( GetDlgItem(IDC_SMARTEDIT)->IsWindowEnabled() != (m_pDisplayClass != 0) )
|
||
|
|
bForceRefresh = true;
|
||
|
|
|
||
|
|
if ( pClass == m_pDisplayClass && !bForceRefresh )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
int lastNumPresentPropertiesCalls = m_nPresentPropertiesCalls;
|
||
|
|
|
||
|
|
bool bNeedsSetupForMode = true;
|
||
|
|
m_pDisplayClass = pClass;
|
||
|
|
|
||
|
|
// In case we're not allowed to present the properties yet, make sure nobody uses m_VarMap.
|
||
|
|
if ( !m_bAllowPresentProperties )
|
||
|
|
{
|
||
|
|
ClearVarList();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!m_pDisplayClass)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Object has no known class - get rid of smartedit.
|
||
|
|
//
|
||
|
|
if (m_bSmartedit || bForceRefresh)
|
||
|
|
{
|
||
|
|
m_bSmartedit = true; // In case bForceRefresh was on, force it to refresh the controls.
|
||
|
|
SetSmartedit(false);
|
||
|
|
bNeedsSetupForMode = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
GetDlgItem(IDC_SMARTEDIT)->EnableWindow(FALSE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
CEntityHelpDlg::SetEditGameClass(m_pDisplayClass);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Known class - enable smartedit.
|
||
|
|
//
|
||
|
|
GetDlgItem(IDC_SMARTEDIT)->EnableWindow(TRUE);
|
||
|
|
|
||
|
|
if (bForceRefresh)
|
||
|
|
m_bSmartedit = !m_bWantSmartedit;
|
||
|
|
|
||
|
|
SetSmartedit(m_bWantSmartedit);
|
||
|
|
}
|
||
|
|
|
||
|
|
// No need to call PresentProperties an extra time if it was called because of SetSmartedit..
|
||
|
|
if ( bNeedsSetupForMode && (m_nPresentPropertiesCalls == lastNumPresentPropertiesCalls) )
|
||
|
|
{
|
||
|
|
PresentProperties();
|
||
|
|
}
|
||
|
|
|
||
|
|
SetReadOnly( ( m_pDisplayClass != m_pEditClass ) || ( m_bCanEdit == false ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool COP_Entity::BrowseModels( char *szModelName, int length, int &nSkin )
|
||
|
|
{
|
||
|
|
bool bChanged = false;
|
||
|
|
|
||
|
|
if (pModelBrowser == NULL)
|
||
|
|
{
|
||
|
|
pModelBrowser = new CModelBrowser( GetMainWnd() );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pModelBrowser->Show();
|
||
|
|
}
|
||
|
|
|
||
|
|
pModelBrowser->SetModelName( szModelName );
|
||
|
|
pModelBrowser->SetSkin( nSkin );
|
||
|
|
|
||
|
|
if (pModelBrowser->DoModal() == IDOK)
|
||
|
|
{
|
||
|
|
pModelBrowser->GetModelName( szModelName, length );
|
||
|
|
pModelBrowser->GetSkin( nSkin );
|
||
|
|
bChanged = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
pModelBrowser->Hide();
|
||
|
|
|
||
|
|
return bChanged;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::BrowseTextures( const char *szFilter, bool bSprite )
|
||
|
|
{
|
||
|
|
// browse for textures
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
|
||
|
|
GDinputvariable * pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// get current texture
|
||
|
|
char szInitialTexture[128];
|
||
|
|
m_pSmartControl->GetWindowText(szInitialTexture, 128);
|
||
|
|
|
||
|
|
// create a texture browser and set it to browse decals
|
||
|
|
CTextureBrowser *pBrowser = new CTextureBrowser(GetMainWnd());
|
||
|
|
|
||
|
|
// setup filter - if any
|
||
|
|
if( szFilter[0] != '\0' )
|
||
|
|
{
|
||
|
|
pBrowser->SetFilter( szFilter );
|
||
|
|
}
|
||
|
|
|
||
|
|
pBrowser->SetInitialTexture(szInitialTexture);
|
||
|
|
|
||
|
|
if (pBrowser->DoModal() == IDOK)
|
||
|
|
{
|
||
|
|
IEditorTexture *pTex = g_Textures.FindActiveTexture(pBrowser->m_cTextureWindow.szCurTexture);
|
||
|
|
|
||
|
|
char szName[MAX_PATH];
|
||
|
|
if (pTex)
|
||
|
|
{
|
||
|
|
pTex->GetShortName(szName);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
szName[0] = '\0';
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bSprite && g_pGameConfig->GetTextureFormat() == tfVMT)
|
||
|
|
{
|
||
|
|
char sprExt[4];
|
||
|
|
Q_snprintf(sprExt, 4, ".vmt");
|
||
|
|
Q_snprintf(szName, MAX_PATH, "%s.vmt", szName);
|
||
|
|
//Strcat is being zee stupido. I prolly have to strip the other string or something.
|
||
|
|
//Q_strcat( szName, sprExt, MAX_PATH );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
m_pSmartControl->SetWindowText(szName);
|
||
|
|
|
||
|
|
// also set variable
|
||
|
|
m_kv.SetValue(pVar->GetName(), szName);
|
||
|
|
m_kvAdded.SetValue(pVar->GetName(), "1");
|
||
|
|
}
|
||
|
|
|
||
|
|
delete pBrowser;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::OnChangeSmartcontrol(void)
|
||
|
|
{
|
||
|
|
if ( m_pSmartControl )
|
||
|
|
{
|
||
|
|
char szValue[KEYVALUE_MAX_VALUE_LENGTH];
|
||
|
|
m_pSmartControl->GetWindowText(szValue, sizeof(szValue));
|
||
|
|
InternalOnChangeSmartcontrol( szValue );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Used only in SmartEdit mode. Called when the contents of the value
|
||
|
|
// edit control change. This is where the edit control contents are
|
||
|
|
// converted to keyvalue data in SmartEdit mode.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::InternalOnChangeSmartcontrol( const char *szValue )
|
||
|
|
{
|
||
|
|
//VPROF_BUDGET( "COP_Entity::OnChangeSmartcontrol", "Object Properties" );
|
||
|
|
|
||
|
|
//
|
||
|
|
// We only respond to this message when it is due to user input.
|
||
|
|
// Don't do anything if we're creating the smart control.
|
||
|
|
//
|
||
|
|
if (m_bIgnoreKVChange)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_LastSmartControlVarValue = szValue;
|
||
|
|
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
GDinputvariable * pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
char szKey[KEYVALUE_MAX_KEY_LENGTH];
|
||
|
|
V_strncpy(szKey, pVar->GetName(), sizeof( szKey ));
|
||
|
|
|
||
|
|
CString strValue = szValue;
|
||
|
|
|
||
|
|
if (pVar->GetType() == ivChoices)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// If a choicelist, change buffer to the string value of what we chose.
|
||
|
|
//
|
||
|
|
const char *pszValueString = pVar->ItemValueForString(szValue);
|
||
|
|
if (pszValueString != NULL)
|
||
|
|
{
|
||
|
|
strValue = pszValueString;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdateKeyValue(szKey, strValue);
|
||
|
|
|
||
|
|
if (m_bEnableControlUpdate)
|
||
|
|
{
|
||
|
|
// Update any controls that are displaying the same data as the edit control.
|
||
|
|
// This code should only be hit as a result of user input in the edit control!
|
||
|
|
if (pVar->GetType() == ivAngle)
|
||
|
|
{
|
||
|
|
// If they changed the "angles" key, update the main angles control.
|
||
|
|
if (!stricmp(pVar->GetName(), "angles"))
|
||
|
|
{
|
||
|
|
m_Angle.SetDifferent(false);
|
||
|
|
m_Angle.SetAngles(strValue, true);
|
||
|
|
}
|
||
|
|
// Otherwise update the Smart angles control.
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_SmartAngle.SetDifferent(false);
|
||
|
|
m_SmartAngle.SetAngles(strValue, true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// We have to do this because it's an owner draw control and we're redoing the background colors.
|
||
|
|
// Normally, Windows will only invalidate the second column.
|
||
|
|
RECT rc;
|
||
|
|
if ( m_VarList.GetItemRect( iSel, &rc, LVIR_BOUNDS ) )
|
||
|
|
m_VarList.InvalidateRect( &rc, FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: this function is called whenever the instance variable or value is changed
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnChangeInstanceVariableControl( void )
|
||
|
|
{
|
||
|
|
if ( m_pEditInstanceVariable && m_pEditInstanceValue )
|
||
|
|
{
|
||
|
|
char szVariable[ KEYVALUE_MAX_VALUE_LENGTH ], szValue[ KEYVALUE_MAX_VALUE_LENGTH ];
|
||
|
|
m_pEditInstanceVariable->GetWindowText( szVariable, sizeof( szVariable ) );
|
||
|
|
m_pEditInstanceValue->GetWindowText( szValue, sizeof( szValue ) );
|
||
|
|
|
||
|
|
if ( szValue[ 0 ] )
|
||
|
|
{
|
||
|
|
strcat( szVariable, " " );
|
||
|
|
strcat( szVariable, szValue );
|
||
|
|
}
|
||
|
|
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
GDinputvariable * pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
char szKey[ KEYVALUE_MAX_KEY_LENGTH ];
|
||
|
|
V_strncpy( szKey, pVar->GetName(), sizeof( szKey ) );
|
||
|
|
|
||
|
|
UpdateKeyValue( szKey, szVariable );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: this function is called whenever the instance parameter is changed
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnChangeInstanceParmControl( void )
|
||
|
|
{
|
||
|
|
if ( m_pEditInstanceVariable && m_pComboInstanceParmType )
|
||
|
|
{
|
||
|
|
char szVariable[ KEYVALUE_MAX_VALUE_LENGTH ], szValue[ KEYVALUE_MAX_VALUE_LENGTH ];
|
||
|
|
m_pEditInstanceVariable->GetWindowText( szVariable, sizeof( szVariable ) );
|
||
|
|
|
||
|
|
int iSmartsel = m_pComboInstanceParmType->GetCurSel();
|
||
|
|
if ( iSmartsel != LB_ERR )
|
||
|
|
{
|
||
|
|
// found a selection - now get the text
|
||
|
|
m_pComboInstanceParmType->GetLBText( iSmartsel, szValue );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pComboInstanceParmType->GetWindowText( szValue, sizeof( szValue ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( szValue[ 0 ] )
|
||
|
|
{
|
||
|
|
strcat( szVariable, " " );
|
||
|
|
strcat( szVariable, szValue );
|
||
|
|
}
|
||
|
|
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
GDinputvariable * pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
char szKey[ KEYVALUE_MAX_KEY_LENGTH ];
|
||
|
|
V_strncpy( szKey, pVar->GetName(), sizeof( szKey ) );
|
||
|
|
|
||
|
|
UpdateKeyValue( szKey, szVariable );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnChangeSmartcontrolSel(void)
|
||
|
|
{
|
||
|
|
// update current value with this
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
if ( !m_pDisplayClass )
|
||
|
|
return;
|
||
|
|
|
||
|
|
GDinputvariable * pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((pVar->GetType() != ivTargetSrc) &&
|
||
|
|
(pVar->GetType() != ivTargetDest) &&
|
||
|
|
(pVar->GetType() != ivTargetNameOrClass) &&
|
||
|
|
(pVar->GetType() != ivChoices) &&
|
||
|
|
(pVar->GetType() != ivNPCClass) &&
|
||
|
|
(pVar->GetType() != ivFilterClass) &&
|
||
|
|
(pVar->GetType() != ivPointEntityClass))
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
CComboBox *pCombo = (CComboBox *)m_pSmartControl;
|
||
|
|
|
||
|
|
char szBuf[128];
|
||
|
|
|
||
|
|
// get current selection
|
||
|
|
int iSmartsel = pCombo->GetCurSel();
|
||
|
|
if (iSmartsel != LB_ERR)
|
||
|
|
{
|
||
|
|
// found a selection - now get the text
|
||
|
|
pCombo->GetLBText(iSmartsel, szBuf);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// just get the text from the combo box (no selection)
|
||
|
|
pCombo->GetWindowText(szBuf, 128);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pVar->GetType() == ivChoices)
|
||
|
|
{
|
||
|
|
const char *pszValue = pVar->ItemValueForString(szBuf);
|
||
|
|
if (pszValue != NULL)
|
||
|
|
{
|
||
|
|
strcpy(szBuf, pszValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_LastSmartControlVarValue = szBuf;
|
||
|
|
|
||
|
|
m_kvAdded.SetValue(pVar->GetName(), "1");
|
||
|
|
m_kv.SetValue(pVar->GetName(), szBuf);
|
||
|
|
RefreshKVListValues( pVar->GetName() );
|
||
|
|
|
||
|
|
// We have to do this because it's an owner draw control and we're redoing the background colors.
|
||
|
|
// Normally, Windows will only invalidate the second column.
|
||
|
|
RECT rc;
|
||
|
|
if ( m_VarList.GetItemRect( iSel, &rc, LVIR_BOUNDS ) )
|
||
|
|
m_VarList.InvalidateRect( &rc, FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : cmd -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::SetNextVar(int cmd)
|
||
|
|
{
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
int nCount = m_VarList.GetItemCount();
|
||
|
|
if(iSel == LB_ERR)
|
||
|
|
return; // no!
|
||
|
|
iSel += cmd;
|
||
|
|
if(iSel == nCount)
|
||
|
|
--iSel;
|
||
|
|
if(iSel == -1)
|
||
|
|
++iSel;
|
||
|
|
SetCurVarListSelection( iSel );
|
||
|
|
OnSelchangeKeyvalues();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Set flags page
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::SetFlagsPage( COP_Flags *pFlagsPage )
|
||
|
|
{
|
||
|
|
m_pFlagsPage = pFlagsPage;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Plays the sound
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnPlaySound(void)
|
||
|
|
{
|
||
|
|
if ( m_eEditType != ivSound && m_eEditType != ivScene )
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Get the name of the sound or VCD.
|
||
|
|
char szCurrentSound[256];
|
||
|
|
m_pSmartControl->GetWindowText(szCurrentSound, 256);
|
||
|
|
if (!szCurrentSound[0])
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Get rid of "scenes/" for scenes.
|
||
|
|
CString filename = szCurrentSound;
|
||
|
|
if ( m_eEditType == ivScene )
|
||
|
|
filename = StripDirPrefix( szCurrentSound, "scenes" );
|
||
|
|
|
||
|
|
// Now play the sound..
|
||
|
|
SoundType_t type;
|
||
|
|
int nIndex;
|
||
|
|
if ( g_Sounds.FindSoundByName( filename, &type, &nIndex ) )
|
||
|
|
g_Sounds.Play( type, nIndex );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Filesystem dialog module wrappers.
|
||
|
|
CSysModule *g_pFSDialogModule = 0;
|
||
|
|
CreateInterfaceFn g_FSDialogFactory = 0;
|
||
|
|
|
||
|
|
void LoadFileSystemDialogModule()
|
||
|
|
{
|
||
|
|
Assert( !g_pFSDialogModule );
|
||
|
|
|
||
|
|
// Load the module with the file system open dialog.
|
||
|
|
const char *pDLLName = "FileSystemOpenDialog.dll";
|
||
|
|
g_pFSDialogModule = Sys_LoadModule( pDLLName );
|
||
|
|
if ( !g_pFSDialogModule ||
|
||
|
|
(g_FSDialogFactory = Sys_GetFactory( g_pFSDialogModule )) == NULL
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if ( g_pFSDialogModule )
|
||
|
|
{
|
||
|
|
Sys_UnloadModule( g_pFSDialogModule );
|
||
|
|
g_pFSDialogModule = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
char str[512];
|
||
|
|
Q_snprintf( str, sizeof( str ), "Can't load %s.\n", pDLLName );
|
||
|
|
AfxMessageBox( str, MB_OK );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void UnloadFileSystemDialogModule()
|
||
|
|
{
|
||
|
|
if ( g_pFSDialogModule )
|
||
|
|
{
|
||
|
|
Sys_UnloadModule( g_pFSDialogModule );
|
||
|
|
g_pFSDialogModule = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Brings up the file browser in the appropriate default directory
|
||
|
|
// based on the type of file being browsed for.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnBrowse(void)
|
||
|
|
{
|
||
|
|
// handle browsing for .fgd "material" type
|
||
|
|
if( m_eEditType == ivMaterial )
|
||
|
|
{
|
||
|
|
BrowseTextures( "\0" );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_eEditType == ivStudioModel && Options.IsVGUIModelBrowserEnabled() )
|
||
|
|
{
|
||
|
|
char szCurrentModel[512];
|
||
|
|
char szCurrentSkin[512];
|
||
|
|
|
||
|
|
const char *result = m_kv.GetValue( "skin" );
|
||
|
|
int nSkin = ( result ) ? Q_atoi( result ) : 0;
|
||
|
|
|
||
|
|
m_pSmartControl->GetWindowText( szCurrentModel, sizeof(szCurrentModel) );
|
||
|
|
|
||
|
|
if ( BrowseModels( szCurrentModel, sizeof(szCurrentModel), nSkin ) )
|
||
|
|
{
|
||
|
|
// model was changed
|
||
|
|
m_pSmartControl->SetWindowText( szCurrentModel );
|
||
|
|
UpdateKeyValue("skin", itoa( nSkin, szCurrentSkin, 10 ));
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// handle browsing for .fgd "decal" type
|
||
|
|
if(m_eEditType == ivDecal)
|
||
|
|
{
|
||
|
|
if (g_pGameConfig->GetTextureFormat() == tfVMT)
|
||
|
|
{
|
||
|
|
BrowseTextures("decals/");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
BrowseTextures("{");
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_eEditType == ivSprite )
|
||
|
|
{
|
||
|
|
BrowseTextures( "sprites/", true);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_eEditType == ivInstanceFile )
|
||
|
|
{
|
||
|
|
OnBrowseInstance();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
char *pszInitialDir = 0;
|
||
|
|
|
||
|
|
|
||
|
|
// Instantiate a dialog.
|
||
|
|
if ( !g_FSDialogFactory )
|
||
|
|
return;
|
||
|
|
|
||
|
|
IFileSystemOpenDialog *pDlg;
|
||
|
|
pDlg = (IFileSystemOpenDialog*)g_FSDialogFactory( FILESYSTEMOPENDIALOG_VERSION, NULL );
|
||
|
|
if ( !pDlg )
|
||
|
|
{
|
||
|
|
char str[512];
|
||
|
|
Q_snprintf( str, sizeof( str ), "Can't create %s interface.", FILESYSTEMOPENDIALOG_VERSION );
|
||
|
|
AfxMessageBox( str, MB_OK );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
pDlg->Init( g_Factory, NULL );
|
||
|
|
|
||
|
|
|
||
|
|
const char *pPathID = "GAME";
|
||
|
|
|
||
|
|
//
|
||
|
|
// Based on the type of file that we are picking, set up the default extension,
|
||
|
|
// default directory, and filters. Each type of file remembers its last directory.
|
||
|
|
//
|
||
|
|
switch (m_eEditType)
|
||
|
|
{
|
||
|
|
case ivStudioModel:
|
||
|
|
{
|
||
|
|
static char szInitialDir[MAX_PATH] = "models";
|
||
|
|
pszInitialDir = szInitialDir;
|
||
|
|
|
||
|
|
pDlg->AddFileMask( "*.jpg" );
|
||
|
|
pDlg->AddFileMask( "*.mdl" );
|
||
|
|
pDlg->SetInitialDir( pszInitialDir, pPathID );
|
||
|
|
pDlg->SetFilterMdlAndJpgFiles( true );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case ivSound:
|
||
|
|
{
|
||
|
|
CString currentValue;
|
||
|
|
m_pSmartControl->GetWindowText( currentValue );
|
||
|
|
|
||
|
|
CSoundBrowser soundDlg( currentValue );
|
||
|
|
if ( soundDlg.m_SoundType != SOUND_TYPE_RAW && soundDlg.m_SoundType != SOUND_TYPE_GAMESOUND )
|
||
|
|
soundDlg.m_SoundType = SOUND_TYPE_GAMESOUND;
|
||
|
|
|
||
|
|
int nRet = soundDlg.DoModal();
|
||
|
|
if ( nRet == IDOK )
|
||
|
|
{
|
||
|
|
m_pSmartControl->SetWindowText(soundDlg.GetSelectedSound());
|
||
|
|
}
|
||
|
|
goto Cleanup;
|
||
|
|
}
|
||
|
|
|
||
|
|
case ivScene:
|
||
|
|
{
|
||
|
|
CString currentValue;
|
||
|
|
m_pSmartControl->GetWindowText( currentValue );
|
||
|
|
CString stripped = StripDirPrefix( currentValue, "scenes" );
|
||
|
|
|
||
|
|
CSoundBrowser soundDlg( stripped );
|
||
|
|
soundDlg.m_SoundType = SOUND_TYPE_SCENE;
|
||
|
|
int nRet = soundDlg.DoModal();
|
||
|
|
if ( nRet == IDOK )
|
||
|
|
{
|
||
|
|
m_pSmartControl->SetWindowText(CString("scenes\\") + soundDlg.GetSelectedSound());
|
||
|
|
}
|
||
|
|
goto Cleanup;
|
||
|
|
}
|
||
|
|
|
||
|
|
default:
|
||
|
|
{
|
||
|
|
pDlg->AddFileMask( "*.*" );
|
||
|
|
pDlg->SetInitialDir( ".", pPathID );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If they picked a file and hit OK, put everything after the last backslash
|
||
|
|
// into the SmartEdit control. If there is no backslash, put the whole filename.
|
||
|
|
//
|
||
|
|
int ret;
|
||
|
|
if ( 1/*g_pFullFileSystem->IsSteam()*/ || CommandLine()->FindParm( "-NewDialogs" ) )
|
||
|
|
ret = pDlg->DoModal();
|
||
|
|
else
|
||
|
|
ret = pDlg->DoModal_WindowsDialog();
|
||
|
|
|
||
|
|
if ( ret == IDOK )
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Save the default folder for next time.
|
||
|
|
//
|
||
|
|
pDlg->GetFilename( pszInitialDir, MAX_PATH );
|
||
|
|
char *pchSlash = strrchr(pszInitialDir, '\\');
|
||
|
|
if (pchSlash != NULL)
|
||
|
|
{
|
||
|
|
*pchSlash = '\0';
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_pSmartControl != NULL)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Reverse the slashes, because the engine expects them that way.
|
||
|
|
//
|
||
|
|
char szTemp[MAX_PATH];
|
||
|
|
pDlg->GetFilename( szTemp, sizeof( szTemp ) );
|
||
|
|
for (unsigned int i = 0; i < strlen(szTemp); i++)
|
||
|
|
{
|
||
|
|
if (szTemp[i] == '\\')
|
||
|
|
{
|
||
|
|
szTemp[i] = '/';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pSmartControl->SetWindowText(szTemp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Cleanup:;
|
||
|
|
pDlg->Release();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: this function will display a file dialog to locate an instance vmf.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnBrowseInstance(void)
|
||
|
|
{
|
||
|
|
const char *pszMapPath = "\\maps\\";
|
||
|
|
CString MapFileName;
|
||
|
|
char FileName[ MAX_PATH ];
|
||
|
|
CString currentValue;
|
||
|
|
CMapDoc *activeDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
|
||
|
|
m_pSmartControl->GetWindowText( currentValue );
|
||
|
|
|
||
|
|
MapFileName = activeDoc->GetPathName();
|
||
|
|
|
||
|
|
CMapInstance::DeterminePath( MapFileName, currentValue, FileName );
|
||
|
|
|
||
|
|
CFileDialog dlg(
|
||
|
|
true, // open dialog?
|
||
|
|
".vmf", // default file extension
|
||
|
|
FileName, // initial filename
|
||
|
|
OFN_ENABLESIZING, // flags
|
||
|
|
"Valve Map Files (*.vmf)|*.vmf||",
|
||
|
|
this );
|
||
|
|
|
||
|
|
if ( dlg.DoModal() == IDOK )
|
||
|
|
{
|
||
|
|
strcpy( FileName, dlg.GetPathName() );
|
||
|
|
V_RemoveDotSlashes( FileName );
|
||
|
|
V_FixDoubleSlashes( FileName );
|
||
|
|
V_strlower( FileName );
|
||
|
|
|
||
|
|
char *pos = strstr( FileName, pszMapPath );
|
||
|
|
if ( pos )
|
||
|
|
{
|
||
|
|
pos += strlen( pszMapPath );
|
||
|
|
*( pos - 1 ) = 0;
|
||
|
|
}
|
||
|
|
else if ( pos == NULL )
|
||
|
|
{
|
||
|
|
const char *pszInstancePath = CMapInstance::GetInstancePath();
|
||
|
|
|
||
|
|
if ( pszInstancePath[ 0 ] != 0 )
|
||
|
|
{
|
||
|
|
pos = strstr( FileName, pszInstancePath );
|
||
|
|
if ( pos )
|
||
|
|
{
|
||
|
|
pos += strlen( pszInstancePath );
|
||
|
|
*( pos - 1 ) = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( pos )
|
||
|
|
{
|
||
|
|
m_pSmartControl->SetWindowText( pos );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnCopy(void)
|
||
|
|
{
|
||
|
|
// copy entity keyvalues
|
||
|
|
kvClipboard.RemoveAll();
|
||
|
|
bKvClipEmpty = FALSE;
|
||
|
|
for ( int i=m_kv.GetFirst(); i != m_kv.GetInvalidIndex(); i=m_kv.GetNext( i ) )
|
||
|
|
{
|
||
|
|
if (stricmp(m_kv.GetKey(i), "origin"))
|
||
|
|
{
|
||
|
|
kvClipboard.SetValue(m_kv.GetKey(i), m_kv.GetValue(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CString strClass = m_cClasses.GetCurrentItem();
|
||
|
|
kvClipboard.SetValue("xxxClassxxx", strClass);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnEntityHelp(void)
|
||
|
|
{
|
||
|
|
CEntityHelpDlg::ShowEntityHelpDialog();
|
||
|
|
CEntityHelpDlg::SetEditGameClass(m_pDisplayClass);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnKillfocusKey(void)
|
||
|
|
{
|
||
|
|
if (!m_bChangingKeyName)
|
||
|
|
return;
|
||
|
|
|
||
|
|
m_bChangingKeyName = false;
|
||
|
|
CString strOutput;
|
||
|
|
|
||
|
|
m_cKey.GetWindowText(strOutput);
|
||
|
|
|
||
|
|
if (strOutput.IsEmpty())
|
||
|
|
{
|
||
|
|
AfxMessageBox("Use the delete button to remove key/value pairs.");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
strOutput.MakeLower();
|
||
|
|
|
||
|
|
// No change
|
||
|
|
if (strOutput == m_szOldKeyName)
|
||
|
|
return;
|
||
|
|
|
||
|
|
char szSaveValue[KEYVALUE_MAX_VALUE_LENGTH];
|
||
|
|
memset(szSaveValue, 0, sizeof(szSaveValue));
|
||
|
|
V_strcpy_safe(szSaveValue, m_kv.GetValue(m_szOldKeyName, NULL));
|
||
|
|
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
if (iSel == LB_ERR)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Get rid of the old key.
|
||
|
|
CString strBuf;
|
||
|
|
strBuf = (CString)(const char*)m_VarList.GetItemData(iSel);
|
||
|
|
m_kv.RemoveKey( strBuf ); // remove from local kv storage
|
||
|
|
m_VarList.DeleteItem(iSel);
|
||
|
|
|
||
|
|
// Add a new key with the new keyname + old value.
|
||
|
|
CNewKeyValue newkv;
|
||
|
|
newkv.m_Key = strOutput;
|
||
|
|
newkv.m_Value = szSaveValue;
|
||
|
|
|
||
|
|
m_kvAdded.SetValue(newkv.m_Key, "1");
|
||
|
|
m_kv.SetValue(newkv.m_Key, newkv.m_Value);
|
||
|
|
|
||
|
|
PresentProperties();
|
||
|
|
|
||
|
|
// Select this property.
|
||
|
|
SetCurVarListSelection( GetKeyValueRowByShortName( newkv.m_Key ) );
|
||
|
|
OnSelchangeKeyvalues();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Does the dirty marking deed
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::PerformMark( const char *szTargetName, bool bClear, bool bNameOrClass )
|
||
|
|
{
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
|
||
|
|
if (pDoc != NULL)
|
||
|
|
{
|
||
|
|
if (szTargetName[0] != '\0')
|
||
|
|
{
|
||
|
|
CMapEntityList Found;
|
||
|
|
|
||
|
|
pDoc->FindEntitiesByName(Found, szTargetName, false);
|
||
|
|
if ((Found.Count() == 0) && bNameOrClass)
|
||
|
|
{
|
||
|
|
pDoc->FindEntitiesByClassName(Found, szTargetName, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Found.Count() != 0)
|
||
|
|
{
|
||
|
|
CMapObjectList Select;
|
||
|
|
FOR_EACH_OBJ( Found, pos )
|
||
|
|
{
|
||
|
|
CMapEntity *pEntity = Found.Element(pos);
|
||
|
|
Select.AddToTail(pEntity);
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( bClear )
|
||
|
|
{
|
||
|
|
// clear & safe previous selection
|
||
|
|
pDoc->SelectObjectList(&Select);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// don't save changes and add object to selection
|
||
|
|
pDoc->SelectObjectList(&Select, scSelect );
|
||
|
|
}
|
||
|
|
|
||
|
|
pDoc->Center2DViewsOnSelection();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
MessageBox("No entities were found with that targetname.", "No entities found", MB_ICONINFORMATION | MB_OK);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Marks all entities whose targetnames match the currently selected
|
||
|
|
// key value.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnMark(void)
|
||
|
|
{
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
GDinputvariable * pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
char szTargetName[MAX_IO_NAME_LEN];
|
||
|
|
m_pSmartControl->GetWindowText(szTargetName, sizeof(szTargetName));
|
||
|
|
|
||
|
|
bool bNameOrClass = false;
|
||
|
|
if (pVar && (pVar->GetType() == ivTargetNameOrClass))
|
||
|
|
{
|
||
|
|
bNameOrClass = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
PerformMark( szTargetName, true, bNameOrClass );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Add the mark to the selection
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnMarkAndAdd(void)
|
||
|
|
{
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
GDinputvariable * pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Build a temporary list of all the currently selected objects because this
|
||
|
|
// process will change the selected objects.
|
||
|
|
CMapEntity **pTemp = (CMapEntity**)stackalloc( m_pObjectList->Count() * sizeof(CMapEntity*) );
|
||
|
|
CUtlVector<CMapEntity*> temp( pTemp, m_pObjectList->Count() );
|
||
|
|
|
||
|
|
FOR_EACH_OBJ( *m_pObjectList, pos )
|
||
|
|
{
|
||
|
|
CMapEntity *pEntity = static_cast<CMapEntity *>(m_pObjectList->Element(pos));
|
||
|
|
temp.AddToTail( pEntity );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Mark all the entities referred to by the current keyvalue in the selected entities.
|
||
|
|
bool bNameOrClass = false;
|
||
|
|
if (pVar && (pVar->GetType() == ivTargetNameOrClass))
|
||
|
|
{
|
||
|
|
bNameOrClass = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < temp.Count(); ++i )
|
||
|
|
{
|
||
|
|
const char *pTargetName = temp[i]->GetKeyValue( pVar->GetName() );
|
||
|
|
if ( pTargetName )
|
||
|
|
{
|
||
|
|
PerformMark( pTargetName, false, bNameOrClass );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnPaste(void)
|
||
|
|
{
|
||
|
|
if(bKvClipEmpty)
|
||
|
|
return;
|
||
|
|
|
||
|
|
CString str;
|
||
|
|
GetCurKey(str);
|
||
|
|
|
||
|
|
// copy entity keyvalues
|
||
|
|
for (int i = kvClipboard.GetFirst(); i != kvClipboard.GetInvalidIndex(); i=kvClipboard.GetNext( i ) )
|
||
|
|
{
|
||
|
|
if (!strcmp(kvClipboard.GetKey(i), "xxxClassxxx"))
|
||
|
|
{
|
||
|
|
m_cClasses.SelectItem( kvClipboard.GetValue(i) );
|
||
|
|
UpdateEditClass(kvClipboard.GetValue(i), false);
|
||
|
|
UpdateDisplayClass(kvClipboard.GetValue(i));
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_kv.SetValue(kvClipboard.GetKey(i), kvClipboard.GetValue(i));
|
||
|
|
m_kvAdded.SetValue(kvClipboard.GetKey(i), "1");
|
||
|
|
}
|
||
|
|
|
||
|
|
PresentProperties();
|
||
|
|
SetCurKey(str);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: For the given key name, builds a list of faces that are common
|
||
|
|
// to all entitie being edited and a list of faces that are found in at
|
||
|
|
// least one entity being edited.
|
||
|
|
// Input : FullFaces -
|
||
|
|
// PartialFaces -
|
||
|
|
// pszKey - the name of the key.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::GetFaceIDListsForKey(CMapFaceIDList &FullFaces, CMapFaceIDList &PartialFaces, const char *pszKey)
|
||
|
|
{
|
||
|
|
CMapWorld *pWorld = GetActiveWorld();
|
||
|
|
|
||
|
|
if ((m_pObjectList != NULL) && (pWorld != NULL))
|
||
|
|
{
|
||
|
|
bool bFirst = true;
|
||
|
|
|
||
|
|
FOR_EACH_OBJ( *m_pObjectList, pos )
|
||
|
|
{
|
||
|
|
CMapClass *pObject = m_pObjectList->Element(pos);
|
||
|
|
CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pObject);
|
||
|
|
if (pEntity != NULL)
|
||
|
|
{
|
||
|
|
const char *pszValue = pEntity->GetKeyValue(pszKey);
|
||
|
|
|
||
|
|
if (bFirst)
|
||
|
|
{
|
||
|
|
pWorld->FaceID_StringToFaceIDLists(&FullFaces, NULL, pszValue);
|
||
|
|
bFirst = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
CMapFaceIDList TempFaces;
|
||
|
|
pWorld->FaceID_StringToFaceIDLists(&TempFaces, NULL, pszValue);
|
||
|
|
|
||
|
|
CMapFaceIDList TempFullFaces = FullFaces;
|
||
|
|
FullFaces.RemoveAll();
|
||
|
|
|
||
|
|
TempFaces.Intersect(TempFullFaces, FullFaces, PartialFaces);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: For the given key name, builds a list of faces that are common
|
||
|
|
// to all entitie being edited and a list of faces that are found in at
|
||
|
|
// least one entity being edited.
|
||
|
|
// Input : FullFaces -
|
||
|
|
// PartialFaces -
|
||
|
|
// pszKey - the name of the key.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// dvs: FIXME: try to eliminate this function
|
||
|
|
void COP_Entity::GetFaceListsForKey(CMapFaceList &FullFaces, CMapFaceList &PartialFaces, const char *pszKey)
|
||
|
|
{
|
||
|
|
CMapWorld *pWorld = GetActiveWorld();
|
||
|
|
|
||
|
|
if ((m_pObjectList != NULL) && (pWorld != NULL))
|
||
|
|
{
|
||
|
|
bool bFirst = true;
|
||
|
|
|
||
|
|
FOR_EACH_OBJ( *m_pObjectList, pos )
|
||
|
|
{
|
||
|
|
CMapClass *pObject = m_pObjectList->Element(pos);
|
||
|
|
CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pObject);
|
||
|
|
if (pEntity != NULL)
|
||
|
|
{
|
||
|
|
const char *pszValue = pEntity->GetKeyValue(pszKey);
|
||
|
|
|
||
|
|
if (bFirst)
|
||
|
|
{
|
||
|
|
pWorld->FaceID_StringToFaceLists(&FullFaces, NULL, pszValue);
|
||
|
|
bFirst = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
CMapFaceList TempFaces;
|
||
|
|
pWorld->FaceID_StringToFaceLists(&TempFaces, NULL, pszValue);
|
||
|
|
|
||
|
|
CMapFaceList TempFullFaces = FullFaces;
|
||
|
|
FullFaces.RemoveAll();
|
||
|
|
|
||
|
|
TempFaces.Intersect(TempFullFaces, FullFaces, PartialFaces);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnPickFaces(void)
|
||
|
|
{
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
Assert(pDoc != NULL);
|
||
|
|
|
||
|
|
if (pDoc == NULL)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
CButton *pButton = (CButton *)GetDlgItem(IDC_PICK_FACES);
|
||
|
|
Assert(pButton != NULL);
|
||
|
|
|
||
|
|
if (pButton != NULL)
|
||
|
|
{
|
||
|
|
if (pButton->GetCheck())
|
||
|
|
{
|
||
|
|
int nSel = GetCurVarListSelection();
|
||
|
|
Assert(nSel != LB_ERR);
|
||
|
|
|
||
|
|
if (nSel != LB_ERR )
|
||
|
|
{
|
||
|
|
GDinputvariable * pVar = GetVariableAt( nSel );
|
||
|
|
if ( pVar != NULL )
|
||
|
|
{
|
||
|
|
Assert((pVar->GetType() == ivSideList) || (pVar->GetType() == ivSide));
|
||
|
|
|
||
|
|
// FACEID TODO: make the faces highlight even when the tool is not active
|
||
|
|
|
||
|
|
//
|
||
|
|
// Build the list of faces that are in all selected entities, and a list
|
||
|
|
// of faces that are in at least one selected entity, so that we can do
|
||
|
|
// multiselect properly.
|
||
|
|
//
|
||
|
|
CMapFaceList FullFaces;
|
||
|
|
CMapFaceList PartialFaces;
|
||
|
|
GetFaceListsForKey(FullFaces, PartialFaces, pVar->GetName());
|
||
|
|
|
||
|
|
// Save the old tool so we can reset to the correct tool when we stop picking.
|
||
|
|
m_ToolPrePick = ToolManager()->GetActiveToolID();
|
||
|
|
m_bPicking = true;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Activate the face picker tool. It will handle the picking of faces.
|
||
|
|
//
|
||
|
|
ToolManager()->SetTool(TOOL_PICK_FACE);
|
||
|
|
|
||
|
|
CToolPickFace *pTool = (CToolPickFace *)ToolManager()->GetToolForID(TOOL_PICK_FACE);
|
||
|
|
pTool->SetSelectedFaces(FullFaces, PartialFaces);
|
||
|
|
m_PickFaceTarget.AttachEntityDlg(this);
|
||
|
|
pTool->Attach(&m_PickFaceTarget);
|
||
|
|
pTool->AllowMultiSelect(pVar->GetType() == ivSideList);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Get the face IDs from the face picker tool.
|
||
|
|
//
|
||
|
|
m_bPicking = false;
|
||
|
|
CToolPickFace *pTool = (CToolPickFace *)ToolManager()->GetToolForID(TOOL_PICK_FACE);
|
||
|
|
UpdatePickFaceText(pTool);
|
||
|
|
ToolManager()->SetTool(TOOL_POINTER);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnPickAngles(void)
|
||
|
|
{
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
Assert(pDoc != NULL);
|
||
|
|
if (pDoc == NULL)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
CButton *pButton = (CButton *)GetDlgItem(IDC_PICK_ANGLES);
|
||
|
|
Assert(pButton != NULL);
|
||
|
|
|
||
|
|
if (pButton != NULL)
|
||
|
|
{
|
||
|
|
if (pButton->GetCheck())
|
||
|
|
{
|
||
|
|
int nSel = GetCurVarListSelection();
|
||
|
|
Assert(nSel != LB_ERR);
|
||
|
|
|
||
|
|
if (nSel != LB_ERR)
|
||
|
|
{
|
||
|
|
GDinputvariable * pVar = GetVariableAt( nSel );
|
||
|
|
if ( pVar != NULL )
|
||
|
|
{
|
||
|
|
Assert(pVar->GetType() == ivAngle);
|
||
|
|
|
||
|
|
// Save the old tool so we can reset to the correct tool when we stop picking.
|
||
|
|
m_ToolPrePick = ToolManager()->GetActiveToolID();
|
||
|
|
m_bPicking = true;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Activate the angles picker tool.
|
||
|
|
//
|
||
|
|
CToolPickAngles *pTool = (CToolPickAngles *)ToolManager()->GetToolForID(TOOL_PICK_ANGLES);
|
||
|
|
m_PickAnglesTarget.AttachEntityDlg(this);
|
||
|
|
pTool->Attach(&m_PickAnglesTarget);
|
||
|
|
|
||
|
|
ToolManager()->SetTool(TOOL_PICK_ANGLES);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
StopPicking();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnPickEntity(void)
|
||
|
|
{
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
Assert(pDoc != NULL);
|
||
|
|
if (pDoc == NULL)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
CButton *pButton = (CButton *)GetDlgItem(IDC_PICK_ENTITY);
|
||
|
|
Assert(pButton != NULL);
|
||
|
|
|
||
|
|
if (pButton != NULL)
|
||
|
|
{
|
||
|
|
if (pButton->GetCheck())
|
||
|
|
{
|
||
|
|
int nSel = GetCurVarListSelection();
|
||
|
|
Assert(nSel != LB_ERR);
|
||
|
|
|
||
|
|
if (nSel != LB_ERR)
|
||
|
|
{
|
||
|
|
GDinputvariable * pVar = GetVariableAt( nSel );
|
||
|
|
if ( pVar != NULL )
|
||
|
|
{
|
||
|
|
// Save the old tool so we can reset to the correct tool when we stop picking.
|
||
|
|
m_ToolPrePick = ToolManager()->GetActiveToolID();
|
||
|
|
m_bPicking = true;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Activate the entity picker tool.
|
||
|
|
//
|
||
|
|
CToolPickEntity *pTool = (CToolPickEntity *)ToolManager()->GetToolForID(TOOL_PICK_ENTITY);
|
||
|
|
m_PickEntityTarget.AttachEntityDlg(this);
|
||
|
|
|
||
|
|
switch (pVar->GetType())
|
||
|
|
{
|
||
|
|
case ivTargetDest:
|
||
|
|
case ivTargetNameOrClass:
|
||
|
|
case ivTargetSrc:
|
||
|
|
{
|
||
|
|
m_PickEntityTarget.SetKeyToRetrieve("targetname");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case ivNodeDest:
|
||
|
|
{
|
||
|
|
m_PickEntityTarget.SetKeyToRetrieve("nodeid");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
default:
|
||
|
|
{
|
||
|
|
Assert(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pTool->Attach(&m_PickEntityTarget);
|
||
|
|
|
||
|
|
ToolManager()->SetTool(TOOL_PICK_ENTITY);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
StopPicking();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Load custom colors
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::LoadCustomColors()
|
||
|
|
{
|
||
|
|
if (m_bCustomColorsLoaded)
|
||
|
|
return;
|
||
|
|
|
||
|
|
char szRootDir[MAX_PATH];
|
||
|
|
char szFullPath[MAX_PATH];
|
||
|
|
APP()->GetDirectory(DIR_PROGRAM, szRootDir);
|
||
|
|
Q_MakeAbsolutePath( szFullPath, MAX_PATH, "customcolors.dat", szRootDir );
|
||
|
|
std::ifstream file(szFullPath, std::ios::in | std::ios::binary);
|
||
|
|
|
||
|
|
if(!file.is_open())
|
||
|
|
{
|
||
|
|
//Nothing to load, but don't keep trying every time the dialog pops up.
|
||
|
|
m_bCustomColorsLoaded = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
file.read((char*)CustomColors, sizeof(CustomColors));
|
||
|
|
file.close();
|
||
|
|
m_bCustomColorsLoaded = true;
|
||
|
|
}
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Save custom colors out to a file
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::SaveCustomColors()
|
||
|
|
{
|
||
|
|
char szRootDir[MAX_PATH];
|
||
|
|
char szFullPath[MAX_PATH];
|
||
|
|
APP()->GetDirectory(DIR_PROGRAM, szRootDir);
|
||
|
|
Q_MakeAbsolutePath( szFullPath, MAX_PATH, "customcolors.dat", szRootDir );
|
||
|
|
std::ofstream file( szFullPath, std::ios::out | std::ios::binary );
|
||
|
|
|
||
|
|
file.write((char*)CustomColors, sizeof(CustomColors));
|
||
|
|
file.close();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: this function will attempt to look up a variable from the variable map
|
||
|
|
// Input : index - non-negative, it is the index into the variable map.
|
||
|
|
// -1 = invalid
|
||
|
|
// negative starting at the INSTANCE_VAR_MAP_START indicates it is a
|
||
|
|
// custom instance parameter.
|
||
|
|
// Output :
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
GDinputvariable *COP_Entity::GetVariableAt( int index )
|
||
|
|
{
|
||
|
|
if ( m_VarMap[ index ] == -1 )
|
||
|
|
{
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_VarMap[ index ] <= INSTANCE_VAR_MAP_START )
|
||
|
|
{
|
||
|
|
return m_InstanceParmData[ INSTANCE_VAR_MAP_START - m_VarMap[ index ] ].m_ParmVariable;
|
||
|
|
}
|
||
|
|
|
||
|
|
return m_pDisplayClass->GetVariableAt( m_VarMap[ index ] );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnPickColor(void)
|
||
|
|
{
|
||
|
|
int iSel = GetCurVarListSelection();
|
||
|
|
GDinputvariable * pVar = GetVariableAt( iSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!m_bCustomColorsLoaded)
|
||
|
|
LoadCustomColors();
|
||
|
|
|
||
|
|
// find current color
|
||
|
|
COLORREF clr;
|
||
|
|
BYTE r = 255, g = 255, b = 255;
|
||
|
|
DWORD brightness = 0xffffffff;
|
||
|
|
|
||
|
|
char szTmp[128], *pTmp;
|
||
|
|
m_pSmartControl->GetWindowText(szTmp, sizeof szTmp);
|
||
|
|
|
||
|
|
pTmp = strtok(szTmp, " ");
|
||
|
|
int iCurToken = 0;
|
||
|
|
while(pTmp)
|
||
|
|
{
|
||
|
|
if(pTmp[0])
|
||
|
|
{
|
||
|
|
if(iCurToken == 3)
|
||
|
|
{
|
||
|
|
brightness = atol(pTmp);
|
||
|
|
}
|
||
|
|
else if(pVar->GetType() == ivColor255)
|
||
|
|
{
|
||
|
|
if(iCurToken == 0)
|
||
|
|
r = BYTE(atol(pTmp));
|
||
|
|
if(iCurToken == 1)
|
||
|
|
g = BYTE(atol(pTmp));
|
||
|
|
if(iCurToken == 2)
|
||
|
|
b = BYTE(atol(pTmp));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(iCurToken == 0)
|
||
|
|
r = BYTE(atof(pTmp) * 255.f);
|
||
|
|
if(iCurToken == 1)
|
||
|
|
g = BYTE(atof(pTmp) * 255.f);
|
||
|
|
if(iCurToken == 2)
|
||
|
|
b = BYTE(atof(pTmp) * 255.f);
|
||
|
|
}
|
||
|
|
++iCurToken;
|
||
|
|
}
|
||
|
|
pTmp = strtok(NULL, " ");
|
||
|
|
}
|
||
|
|
|
||
|
|
clr = RGB(r, g, b);
|
||
|
|
|
||
|
|
CColorDialog dlg(clr, CC_FULLOPEN);
|
||
|
|
dlg.m_cc.lpCustColors = CustomColors;
|
||
|
|
if(dlg.DoModal() != IDOK)
|
||
|
|
return;
|
||
|
|
|
||
|
|
SaveCustomColors();
|
||
|
|
|
||
|
|
r = GetRValue(dlg.m_cc.rgbResult);
|
||
|
|
g = GetGValue(dlg.m_cc.rgbResult);
|
||
|
|
b = GetBValue(dlg.m_cc.rgbResult);
|
||
|
|
|
||
|
|
// set back in field
|
||
|
|
if(pVar->GetType() == ivColor255)
|
||
|
|
{
|
||
|
|
sprintf(szTmp, "%d %d %d", r, g, b);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
sprintf(szTmp, "%.3f %.3f %.3f", float(r) / 255.f,
|
||
|
|
float(g) / 255.f, float(b) / 255.f);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(brightness != 0xffffffff)
|
||
|
|
sprintf(szTmp + strlen(szTmp), " %d", brightness);
|
||
|
|
|
||
|
|
m_pSmartControl->SetWindowText(szTmp);
|
||
|
|
RefreshKVListValues();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnSetfocusKey(void)
|
||
|
|
{
|
||
|
|
m_cKey.GetWindowText(m_szOldKeyName);
|
||
|
|
|
||
|
|
if (m_szOldKeyName.IsEmpty())
|
||
|
|
return;
|
||
|
|
|
||
|
|
m_szOldKeyName.MakeLower();
|
||
|
|
|
||
|
|
m_bChangingKeyName = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Called whenever we are hidden or shown.
|
||
|
|
// Input : bShow - TRUE if we are being shown, FALSE if we are being hidden.
|
||
|
|
// nStatus -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnShowPropertySheet(BOOL bShow, UINT nStatus)
|
||
|
|
{
|
||
|
|
if (bShow)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Being shown. Make sure the data in the smartedit control is correct.
|
||
|
|
//
|
||
|
|
OnSelchangeKeyvalues();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Being hidden. Abort face picking if we are doing so.
|
||
|
|
//
|
||
|
|
StopPicking();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : nChar -
|
||
|
|
// nRepCnt -
|
||
|
|
// nFlags -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMyEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
|
||
|
|
{
|
||
|
|
CEdit::OnChar(nChar, nRepCnt, nFlags);
|
||
|
|
return;
|
||
|
|
|
||
|
|
if(nChar == 1) // ctrl+a
|
||
|
|
{
|
||
|
|
m_pParent->SetNextVar(1);
|
||
|
|
}
|
||
|
|
else if(nChar == 11) // ctrl+q
|
||
|
|
{
|
||
|
|
m_pParent->SetNextVar(-1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
CEdit::OnChar(nChar, nRepCnt, nFlags);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : nChar -
|
||
|
|
// nRepCnt -
|
||
|
|
// nFlags -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMyComboBox::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
|
||
|
|
{
|
||
|
|
CComboBox::OnChar(nChar, nRepCnt, nFlags);
|
||
|
|
return;
|
||
|
|
|
||
|
|
if(nChar == 1) // ctrl+a
|
||
|
|
{
|
||
|
|
m_pParent->SetNextVar(1);
|
||
|
|
}
|
||
|
|
else if(nChar == 11) // ctrl+q
|
||
|
|
{
|
||
|
|
m_pParent->SetNextVar(-1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
CComboBox::OnChar(nChar, nRepCnt, nFlags);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Gets the new face ID list from the pick face tool and updates the
|
||
|
|
// contents of the edit control with space-delimited face IDs.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::UpdatePickFaceText(CToolPickFace *pTool)
|
||
|
|
{
|
||
|
|
char szList[KEYVALUE_MAX_VALUE_LENGTH];
|
||
|
|
szList[0] = '\0';
|
||
|
|
|
||
|
|
CMapFaceList FaceListFull;
|
||
|
|
CMapFaceList FaceListPartial;
|
||
|
|
|
||
|
|
pTool->GetSelectedFaces(FaceListFull, FaceListPartial);
|
||
|
|
if (!CMapWorld::FaceID_FaceListsToString(szList, sizeof(szList), &FaceListFull, &FaceListPartial))
|
||
|
|
{
|
||
|
|
MessageBox("Too many faces selected for this keyvalue to hold. Deselect some faces.", "Error", MB_OK);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Update the edit control text with the new face IDs. This text will be
|
||
|
|
// stuffed into the local keyvalue storage in OnChangeSmartControl.
|
||
|
|
//
|
||
|
|
m_pSmartControl->SetWindowText(szList);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Handles the message sent by the angles custom control when the user
|
||
|
|
// changes the angle via the angle box or edit combo.
|
||
|
|
// Input : WPARAM - The ID of the control that sent the message.
|
||
|
|
// LPARAM - Unused.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
LRESULT COP_Entity::OnChangeAngleBox(WPARAM nID, LPARAM)
|
||
|
|
{
|
||
|
|
CString strKey;
|
||
|
|
GetCurKey(strKey);
|
||
|
|
|
||
|
|
char szValue[KEYVALUE_MAX_VALUE_LENGTH];
|
||
|
|
bool bUpdateControl = false;
|
||
|
|
if ((nID == IDC_ANGLEBOX) || (nID == IDC_ANGLEEDIT))
|
||
|
|
{
|
||
|
|
// From the main "angles" box.
|
||
|
|
m_Angle.GetAngles(szValue);
|
||
|
|
|
||
|
|
// Only update the edit control text if the "angles" key is selected.
|
||
|
|
if (!strKey.CompareNoCase("angles"))
|
||
|
|
{
|
||
|
|
bUpdateControl = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Slam "angles" into the key name since that's the key we're modifying.
|
||
|
|
strKey = "angles";
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// From the secondary angles box that edits the selected keyvalue.
|
||
|
|
m_SmartAngle.GetAngles(szValue);
|
||
|
|
bUpdateControl = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Commit the change to our local storage.
|
||
|
|
UpdateKeyValue(strKey, szValue);
|
||
|
|
|
||
|
|
if (bUpdateControl)
|
||
|
|
{
|
||
|
|
if (m_bSmartedit)
|
||
|
|
{
|
||
|
|
// Reflect the change in the SmartEdit control.
|
||
|
|
Assert(m_pSmartControl);
|
||
|
|
if (m_pSmartControl)
|
||
|
|
{
|
||
|
|
m_bEnableControlUpdate = false;
|
||
|
|
m_pSmartControl->SetWindowText(szValue);
|
||
|
|
m_bEnableControlUpdate = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Reflect the change in the keyvalue control.
|
||
|
|
m_bEnableControlUpdate = false;
|
||
|
|
m_cValue.SetWindowText(szValue);
|
||
|
|
m_bEnableControlUpdate = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void COP_Entity::OnCameraDistance(void)
|
||
|
|
{
|
||
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
||
|
|
CMapView3D *pView = pDoc->GetFirst3DView();
|
||
|
|
if ( !pView )
|
||
|
|
return;
|
||
|
|
const CCamera *camera = pView->GetCamera();
|
||
|
|
Vector cameraPos;
|
||
|
|
camera->GetViewPoint( cameraPos );
|
||
|
|
Assert(pDoc != NULL);
|
||
|
|
if (pDoc == NULL)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
int nSel = GetCurVarListSelection();
|
||
|
|
Assert(nSel != LB_ERR);
|
||
|
|
|
||
|
|
if (nSel != LB_ERR)
|
||
|
|
{
|
||
|
|
GDinputvariable * pVar = GetVariableAt( nSel );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
Vector objectPos;
|
||
|
|
const CMapObjectList *pSelection = pDoc->GetSelection()->GetList();
|
||
|
|
int iSelectionCount = pSelection->Count();
|
||
|
|
if ( iSelectionCount == 1 )
|
||
|
|
{
|
||
|
|
// Only 1 entity selected.. we can just set our SmartControl text and the change will get applied
|
||
|
|
// when they close the properties dialog or click Apply.
|
||
|
|
CMapClass *selectedObject = pSelection->Element(iSelectionCount - 1);
|
||
|
|
selectedObject->GetOrigin( objectPos );
|
||
|
|
int distance = VectorLength( cameraPos - objectPos );
|
||
|
|
char buf[255];
|
||
|
|
itoa( distance, buf, 10 );
|
||
|
|
m_pSmartControl->SetWindowText(buf);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Multiple entities selected. We have to apply the current set of changes,
|
||
|
|
// Set the value in each entity and set the kv text to VALUE_DIFFERENT_STRING so it doesn't overwrite anything when we Apply().
|
||
|
|
int index = m_kv.FindByKeyName( pVar->GetName() );
|
||
|
|
if ( index == m_kv.GetInvalidIndex() )
|
||
|
|
return;
|
||
|
|
|
||
|
|
// First set VALUE_DIFFERENT_STRING in our smart control and in m_kv.
|
||
|
|
m_pSmartControl->SetWindowText( VALUE_DIFFERENT_STRING );
|
||
|
|
MDkeyvalue &kvCur = m_kv.GetKeyValue( index );
|
||
|
|
V_strncpy( kvCur.szValue, VALUE_DIFFERENT_STRING, sizeof( kvCur.szValue ) );
|
||
|
|
|
||
|
|
// Get the list of objects we'll apply this to.
|
||
|
|
CMapObjectList objectList;
|
||
|
|
FOR_EACH_OBJ( *m_pObjectList, pos )
|
||
|
|
{
|
||
|
|
CMapClass *pObject = m_pObjectList->Element(pos);
|
||
|
|
if ( pObject && !IsWorldObject( pObject ) && dynamic_cast <CEditGameClass *>(pObject) )
|
||
|
|
objectList.AddToTail( pObject );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Now set the distance property directly on the selected entities.
|
||
|
|
if ( objectList.Count() > 0 )
|
||
|
|
{
|
||
|
|
// Setup undo stuff.
|
||
|
|
GetHistory()->MarkUndoPosition( pDoc->GetSelection()->GetList(), "Change Properties");
|
||
|
|
GetHistory()->Keep( &objectList );
|
||
|
|
|
||
|
|
FOR_EACH_OBJ( objectList, pos )
|
||
|
|
{
|
||
|
|
CMapClass *pObject = m_pObjectList->Element(pos);
|
||
|
|
CEditGameClass *pEdit = dynamic_cast <CEditGameClass *>(pObject);
|
||
|
|
Assert( pObject && pEdit );
|
||
|
|
|
||
|
|
pObject->GetOrigin( objectPos );
|
||
|
|
int distance = VectorLength( cameraPos - objectPos );
|
||
|
|
char buf[255];
|
||
|
|
itoa( distance, buf, 10 );
|
||
|
|
|
||
|
|
pEdit->SetKeyValue( pVar->GetName(), buf );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::OnTextChanged( const char *pText )
|
||
|
|
{
|
||
|
|
m_bClassSelectionEmpty = false;
|
||
|
|
UpdateDisplayClass( pText );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bool COP_Entity::OnUnknownEntry( const char *pText )
|
||
|
|
{
|
||
|
|
// They entered a classname we don't recognize. Get rid of all keys.
|
||
|
|
// It's about to call OnTextChanged, and we'll null m_pDisplayClass, disable SmartEdit, etc.
|
||
|
|
m_kv.RemoveAll();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void COP_Entity::OnSmartControlTargetNameChanged( const char *pText )
|
||
|
|
{
|
||
|
|
CFilteredComboBox *pCombo = dynamic_cast<CFilteredComboBox*>( m_pSmartControl );
|
||
|
|
Assert( pCombo );
|
||
|
|
if ( pCombo )
|
||
|
|
{
|
||
|
|
InternalOnChangeSmartcontrol( pCombo->GetCurrentItem() );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::GetItemColor( int iItem, COLORREF *pBackgroundColor, COLORREF *pTextColor )
|
||
|
|
{
|
||
|
|
// Setup the background color.
|
||
|
|
EKeyState eState;
|
||
|
|
bool bMissingTarget;
|
||
|
|
GetKeyState( (const char*)m_VarList.GetItemData( iItem ), &eState, &bMissingTarget );
|
||
|
|
|
||
|
|
if ( eState == k_EKeyState_Modified )
|
||
|
|
*pBackgroundColor = g_BgColor_Edited;
|
||
|
|
else if ( eState == k_EKeyState_AddedManually )
|
||
|
|
*pBackgroundColor = g_BgColor_Added;
|
||
|
|
else if ( eState == k_EKeyState_InstanceParm )
|
||
|
|
*pBackgroundColor = g_BgColor_InstanceParm;
|
||
|
|
else
|
||
|
|
*pBackgroundColor = g_BgColor_Default;
|
||
|
|
|
||
|
|
// Setup the text color.
|
||
|
|
if ( bMissingTarget )
|
||
|
|
*pTextColor = g_TextColor_MissingTarget;
|
||
|
|
else
|
||
|
|
*pTextColor = g_TextColor_Normal;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bool COP_Entity::CustomDrawItemValue( const LPDRAWITEMSTRUCT p, const RECT *pRect )
|
||
|
|
{
|
||
|
|
if ( !m_bSmartedit || p->itemID < 0 || p->itemID >= ARRAYSIZE(m_VarMap) || m_VarMap[p->itemID] < 0 )
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if ( !m_pDisplayClass )
|
||
|
|
return false;
|
||
|
|
|
||
|
|
GDinputvariable * pVar = GetVariableAt( p->itemID );
|
||
|
|
if ( pVar == NULL )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if ( pVar && (pVar->GetType() == ivColor255 || pVar->GetType() == ivColor1) )
|
||
|
|
{
|
||
|
|
const char *pValue = m_kv.GetValue( pVar->GetName() );
|
||
|
|
if ( pValue )
|
||
|
|
{
|
||
|
|
int r, g, b;
|
||
|
|
if ( pVar->GetType() == ivColor255 )
|
||
|
|
{
|
||
|
|
sscanf( pValue, "%d %d %d", &r, &g, &b );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
float fr, fg, fb;
|
||
|
|
sscanf( pValue, "%f %f %f", &fr, &fg, &fb );
|
||
|
|
r = (int)(fr * 255.0);
|
||
|
|
g = (int)(fg * 255.0);
|
||
|
|
b = (int)(fb * 255.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
HBRUSH hBrush = CreateSolidBrush( RGB( r, g, b ) );
|
||
|
|
HPEN hPen = CreatePen( PS_SOLID, 0, RGB(0,0,0) );
|
||
|
|
SelectObject( p->hDC, hBrush );
|
||
|
|
SelectObject( p->hDC, hPen );
|
||
|
|
|
||
|
|
RECT rc = *pRect;
|
||
|
|
Rectangle( p->hDC, rc.left+6, rc.top+2, rc.right-6, rc.bottom-2 );
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: The flags page calls this whenever a spawnflag changes in it.
|
||
|
|
// Input : preserveMask tells the bits you should NOT change in the spawnflags value.
|
||
|
|
// newValues is the values of the other bits.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void COP_Entity::OnUpdateSpawnFlags( unsigned long preserveMask, unsigned long newValues )
|
||
|
|
{
|
||
|
|
const char *p = m_kv.GetValue( SPAWNFLAGS_KEYNAME );
|
||
|
|
if ( !p )
|
||
|
|
return;
|
||
|
|
|
||
|
|
unsigned long oldValue = 0;
|
||
|
|
sscanf( p, "%lu", &oldValue );
|
||
|
|
|
||
|
|
unsigned long newValue = (oldValue & preserveMask) | (newValues & ~preserveMask);
|
||
|
|
|
||
|
|
// We print the string ourselves here because the int version of SetValue will show a negative number
|
||
|
|
// if we exceed 1<<31.
|
||
|
|
char str[512];
|
||
|
|
V_snprintf( str, sizeof( str ), "%lu", newValue );
|
||
|
|
m_kv.SetValue( SPAWNFLAGS_KEYNAME, str );
|
||
|
|
|
||
|
|
RefreshKVListValues( SPAWNFLAGS_KEYNAME );
|
||
|
|
OnSelchangeKeyvalues(); // Refresh the control with its value in case it's selected currently.
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void COP_Entity::OnSize( UINT nType, int cx, int cy )
|
||
|
|
{
|
||
|
|
m_AnchorMgr.OnSize();
|
||
|
|
}
|
||
|
|
|
||
|
|
|