archive
/
tf2
mirror of https://github.com/sr2echa/TF2-Source-Code
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Team Fortress 2 Source Code as on 22/4/2020
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.
8 Commits
1 Branch
0 Tags
1.4 GiB
 
 
 
 
 
 
Tree: df62d5da09
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'df62d5da09'
${ noResults }
tf2/tf2_src/hammer/op_entity.cpp

4829 lines
131 KiB
Raw Blame History

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