csgo/cstrike15_src/hammer/op_entity.cpp

//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ====
//
// Purpose: 
//
//=============================================================================

#include "stdafx.h"
#include "hammer.h"
#include "EntityHelpDlg.h"
#include "EntityReportDlg.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"
#include "dlglistmanage.h"
#include "smartptr.h"
#include "instancing_helper.h"

// 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 IDC_SMARTCONTROL_INSTANCE_DEFAULT	6

#define SPAWNFLAGS_KEYNAME	"spawnflags"

#define INSTANCE_VAR_MAP_START		-10

extern GameData *pGD;		// current game data


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};


//-----------------------------------------------------------------------------
// 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++ )
	{
		const CMapEntity *pEntity = pList->Element( i ).GetObject();

		if ( !pEntity )
		{
			continue;
		}

		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 = (CUtlReference< CMapClass >)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)
	ON_EN_CHANGE(IDC_SMARTCONTROL_INSTANCE_DEFAULT, 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
};


//-----------------------------------------------------------------------------
// Less function for use with CUtlMap and CUtlString keys
//-----------------------------------------------------------------------------
bool UtlStringLessFunc( const CString &lhs, const CString &rhs )
{
	return ( Q_strcmp( lhs, rhs ) < 0 );
}



//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
COP_Entity::COP_Entity()
	: CObjectPage(COP_Entity::IDD), 
	m_cClasses( this ), 
	m_SmartControlTargetNameRouter( this ),
	m_VarList( this ),
	m_InstanceParmData( UtlStringLessFunc )
{
	//{{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_pEditInstanceDefault = 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);

	m_pInstanceVar = NULL;
	m_pModelBrowser = NULL;
	m_pParticleBrowser = NULL;

	m_bCustomColorsLoaded = false; //Make sure they get loaded!
	memset(CustomColors, 0, sizeof(CustomColors));
}


//-----------------------------------------------------------------------------
// Purpose: Destructor.
//-----------------------------------------------------------------------------
COP_Entity::~COP_Entity(void)
{
	DestroySmartControls();

	delete m_pModelBrowser;
	m_pModelBrowser = NULL;

	delete m_pParticleBrowser;
	m_pParticleBrowser = 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
			{
				int 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

		strcpy(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( SaveData_Reason_t reason )
{
	//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 = (CUtlReference< CMapClass >)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 );
			pSearchString = pVar->GetLongName();
		}
	}

	LVFINDINFO fi;
	memset( &fi, 0, sizeof( fi ) );
	fi.flags = LVFI_STRING;
	fi.psz = pSearchString;
	return m_VarList.FindItem( &fi );
}


class CStringListTokenizer
{
public:
	explicit CStringListTokenizer( char const *szString );

	char const * NextToken();
	char const * CurrentToken() const;

	static inline char Separator() { return ' '; }
	static void TrimPrefixes( char *pszBuffer, char const *pszPrefix );

protected:
	CArrayAutoPtr< char > m_pString;
	char *m_pNextToken;
	char *m_pCurrentToken;
};

CStringListTokenizer::CStringListTokenizer(const char *szString) :
	m_pNextToken( NULL ),
	m_pCurrentToken( NULL )
{
	if ( szString )
	{
		size_t len = strlen( szString );
		m_pString.Attach( new char[ len + 1 ] );
		strcpy( m_pString.Get(), szString );
		m_pNextToken = m_pString.Get();
		m_pCurrentToken = NULL;
	}
}

char const * CStringListTokenizer::NextToken()
{
	char const chSeparator = Separator();
	while ( m_pNextToken &&
		*m_pNextToken &&
		*m_pNextToken == chSeparator )
		++ m_pNextToken;

	if ( !m_pNextToken || !*m_pNextToken )
		return NULL;

	char *pNextToken = strchr( m_pNextToken, chSeparator );
	if ( pNextToken )
	{
		*pNextToken = 0;
		m_pCurrentToken = m_pNextToken;
		m_pNextToken = pNextToken + 1;
	}
	else
	{
		m_pCurrentToken = m_pNextToken;
		m_pNextToken = NULL;
	}
	
	return CurrentToken();
}

char const * CStringListTokenizer::CurrentToken() const
{
	return m_pCurrentToken;
}

void CStringListTokenizer::TrimPrefixes( char *pszBuffer, char const *pszPrefix )
{
	char *pszResult = pszBuffer;
	char *pszResultEnd = pszBuffer + strlen( pszBuffer );

	char const *szPrefix = pszPrefix;
	int lenPrefix = strlen( szPrefix );

	while ( pszResult < pszResultEnd )
	{
		if ( StringHasPrefix( pszResult, szPrefix ) )
		{
			memmove( pszResult, pszResult + lenPrefix, pszResultEnd + 1 - ( pszResult + lenPrefix ) );
		}
		pszResult = strchr( pszResult, Separator() );
		if ( !pszResult )
			break;
		else
			++ pszResult;
	}
}


//-----------------------------------------------------------------------------
// 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) || (eType == ivScript ))
					{
						// 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 if ( eType == ivScriptList )
					{
						// Show filenames on the list
						CStringListTokenizer lstScripts( pUnformattedValue );
						char *pchFill = tmpValueBuf;
						while ( char const *szEntry = lstScripts.NextToken() )
						{
							const char *pLastSlash = max( strrchr( szEntry, '\\' ), strrchr( szEntry, '/' ) );
							if ( !pLastSlash )
								pLastSlash = szEntry;
							else
								++ pLastSlash;

							if ( pchFill != tmpValueBuf )
								*( pchFill ++ ) = ' ';

							Q_strncpy( pchFill, pLastSlash, tmpValueBuf + sizeof( tmpValueBuf ) - pchFill );
							pchFill += strlen( pLastSlash );
							pValue = tmpValueBuf;

							if ( pchFill >= tmpValueBuf + sizeof( tmpValueBuf ) )
								break;
						}
					}
				}
			}
			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 )
		{
			CMapClass *pMapClass = (CUtlReference< CMapClass >)m_pObjectList->Element( 0 );
			CMapEntity *pEntity = static_cast< CMapEntity * >( pMapClass );

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


//-----------------------------------------------------------------------------
// 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 == ivScript) || (eType == ivScriptList) ||
			 (eType == ivParticleSystem) || ( 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 )
		{
			const CMapEntity *pEntity = pEntityList->Element(pos).GetObject();
			GDclass *pClass = pEntity ? pEntity->GetClass() : NULL;
			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;
	}

	if ( pVar->GetType() != ivScriptList )
	{
		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;

		CButton *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);
	}
	else if ( pVar->GetType() == ivScriptList )
	{
		CButton *pButton = new CButton;
		pButton->CreateEx(0, "Button", "Manage...", 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;
		}
	}

	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, *pDefault;
	const int	VariableLimit = 50;

	pVariable = pType = pDefault = "";
	if ( pValue )
	{
		strcpy( ValueData, pValue );
		pVariable = ValueData;
		char *pos = strchr( ValueData, ' ' );
		if ( pos )
		{
			*pos = 0;
			pos++;
			pType = pos;

			pos = strchr( ( char * )pType, ' ' );
			if ( pos )
			{
				*pos = 0;
				pos++;
				pDefault = 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 );
	ctrlrect.left -= 50;
	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 );


	ctrlrect.top += 26;
	ctrlrect.bottom += 26;

	CStatic		*pStaticInstanceDefault;
	pStaticInstanceDefault = new CStatic;
	pStaticInstanceDefault->CreateEx( WS_EX_LEFT, "STATIC", "Default:", WS_CHILD | WS_VISIBLE | SS_LEFT, ctrlrect.left, ctrlrect.top, 50, 24, GetSafeHwnd(), HMENU( IDC_STATIC ) );
	pStaticInstanceDefault->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );

	m_pEditInstanceDefault = new CEdit;
	m_pEditInstanceDefault->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_DEFAULT ) );
	m_pEditInstanceDefault->SendMessage( WM_SETFONT, ( WPARAM )hControlFont );
	m_pEditInstanceDefault->SetWindowText( pDefault );
	m_pEditInstanceDefault->SetLimitText( KEYVALUE_MAX_KEY_LENGTH - VariableLimit - 2 );	// to account for null and space in between

	if ( pVar->IsReadOnly() )
	{
		m_pEditInstanceDefault->EnableWindow( FALSE );
	}

	m_pSmartControl = m_pEditInstanceVariable;
	m_SmartControls.AddToTail( m_pEditInstanceVariable );
	m_SmartControls.AddToTail( m_pComboInstanceParmType );
	m_SmartControls.AddToTail( m_pEditInstanceDefault );
	m_SmartControls.AddToTail( pStaticInstanceVariable );
	m_SmartControls.AddToTail( pStaticInstanceValue );
	m_SmartControls.AddToTail( pStaticInstanceDefault );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
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, 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 i = 0; i < nCount; i++)
				{
					nMask |= (unsigned int)pVar->GetFlagMask(i);
				}
				
				// 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;

	CModelBrowser *pModelBrowser = GetMainWnd()->GetModelBrowser();
	pModelBrowser->Show();

	CUtlVector<AssetUsageInfo_t> usedModels;
	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( pDoc )
	{
		pDoc->GetUsedModels( usedModels );
	}

	pModelBrowser->SetUsedModelList( usedModels );
	pModelBrowser->SetModelName( szModelName );
	pModelBrowser->SetSkin( nSkin );

	int nRet = pModelBrowser->DoModal();

	if ( nRet == IDOK)
	{
		pModelBrowser->GetModelName( szModelName, length );
		pModelBrowser->GetSkin( nSkin );
		bChanged = true;
	}
	else if ( nRet == ID_FIND_ASSET )
	{
		char szModelName[1024];
		pModelBrowser->GetModelName( szModelName, sizeof( szModelName ) );

		EntityReportFilterParms_t filter;
		filter.FilterByKeyValue( "model", szModelName );

		CEntityReportDlg::ShowEntityReport( pDoc, this, &filter );
	}

	pModelBrowser->Hide();

	return bChanged;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool COP_Entity::BrowseParticles( char *szParticleSysName, int length )
{
	bool bChanged = false;

	if (m_pParticleBrowser == NULL)
	{
		m_pParticleBrowser = new CParticleBrowser( GetMainWnd() );
	}

	m_pParticleBrowser->SetParticleSysName( szParticleSysName );

	if (m_pParticleBrowser->DoModal() == IDOK)
	{
		m_pParticleBrowser->GetParticleSysName( szParticleSysName, length );
		bChanged = true;
	}

	delete m_pParticleBrowser;
	m_pParticleBrowser = NULL;

	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 ], szDefault[ 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 );
		}

		m_pEditInstanceDefault->GetWindowText( szDefault, sizeof( szDefault ) );
		if ( szDefault[ 0 ] )
		{
			strcat( szVariable, " " );
			strcat( szVariable, szDefault );
		}

		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 == ivScriptList )
		OnManageList();

	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 );
}

void COP_Entity::OnManageList()
{
	CDlgListManage dlg( this, this, m_pObjectList );
	int nResult = dlg.DoModal();
	if ( nResult == IDOK )
	{
		// Have the dialog commit changes
		dlg.SaveScriptChanges();
		
		// Mark it as changed
		GetMainWnd()->pObjectProperties->MarkDataDirty();
	}
}


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

	if ( m_eEditType == ivParticleSystem )
	{
		char szCurrentParticleSys[512];

		m_pSmartControl->GetWindowText( szCurrentParticleSys, sizeof(szCurrentParticleSys) );

		if ( BrowseParticles( szCurrentParticleSys, sizeof(szCurrentParticleSys) ) )
		{
			// model was changed
			m_pSmartControl->SetWindowText( szCurrentParticleSys );
		}
		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 ivScript:
		{
			static char szInitialDir[MAX_PATH] = "scripts\\vscripts";
			pszInitialDir = szInitialDir;

			pDlg->AddFileMask( "*.nut" );
			pDlg->AddFileMask( "*.gm" );
			pDlg->SetInitialDir( pszInitialDir, pPathID );
			break;
		}

		case ivScriptList:
		{
			static char szInitialDir[MAX_PATH] = "scripts\\vscripts";
			pszInitialDir = szInitialDir;

			pDlg->AddFileMask( "*.nut" );
			pDlg->AddFileMask( "*.gm" );
			pDlg->SetInitialDir( pszInitialDir, pPathID );
			pDlg->AllowMultiSelect( 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:
		{
			static char szInitialDir[MAX_PATH] = ".";
			pszInitialDir = szInitialDir;

			pDlg->AddFileMask( "*.*" );
			pDlg->SetInitialDir( pszInitialDir, 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 ( g_pFullFileSystem->IsSteam() || CommandLine()->FindParm( "-NewDialogs" ) )
		ret = pDlg->DoModal();
	else
		ret = pDlg->DoModal_WindowsDialog();

	if ( ret == IDOK )
	{
		//
		// Save the default folder for next time.
		//

		int numResultCharsNeeded = pDlg->GetFilenameBufferSize();
		CArrayAutoPtr< char > szResultBuffer( new char[ numResultCharsNeeded ] );
		pDlg->GetFilename( szResultBuffer.Get(), numResultCharsNeeded );
		
		// If you hit this assert you haven't set up static storage for your initial
		// directory for the next time the user hits Browse for this type of file.
		// See ivStudioModel and ivScript above.
		Assert( pszInitialDir != NULL );

		if ( pszInitialDir )
		{
			char *pSep = strchr( szResultBuffer.Get(), CStringListTokenizer::Separator() );
			_snprintf( pszInitialDir, MAX_PATH, "%.*s",
				pSep ? pSep - szResultBuffer.Get() : MAX_PATH,
				szResultBuffer.Get() );
			
			char *pchSlash = strrchr(pszInitialDir, '\\');
			if (pchSlash != NULL)
			{
				*pchSlash = '\0';
			}
		}
		
		if (m_pSmartControl != NULL)
		{
			Q_FixSlashes( szResultBuffer.Get(), '/' );

			if ( m_eEditType == ivScriptList )
			{
				CStringListTokenizer::TrimPrefixes( szResultBuffer.Get(), "scripts/vscripts/" );
			}

			m_pSmartControl->SetWindowText( szResultBuffer.Get() );
		}
	}

Cleanup:;
	pDlg->Release();
}

bool COP_Entity::HandleBrowse( CStringList &lstBrowse )
{
	if ( m_eEditType != ivScriptList )
		return false;

	if ( !g_FSDialogFactory )
		return false;

	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 false;
	}
	pDlg->Init( g_Factory, NULL );

	pDlg->AddFileMask( "*.nut" );
	pDlg->AddFileMask( "*.gm" );
	pDlg->AllowMultiSelect( true );

	int ret;
	if ( g_pFullFileSystem->IsSteam() || CommandLine()->FindParm( "-NewDialogs" ) )
		ret = pDlg->DoModal();
	else
		ret = pDlg->DoModal_WindowsDialog();

	if ( ret == IDOK )
	{
		int numResultCharsNeeded = pDlg->GetFilenameBufferSize();
		CArrayAutoPtr< char > szResultBuffer( new char[ numResultCharsNeeded ] );
		pDlg->GetFilename( szResultBuffer.Get(), numResultCharsNeeded );

		Q_FixSlashes( szResultBuffer.Get(), '/' );

		if ( m_eEditType == ivScriptList )
		{
			CStringListTokenizer::TrimPrefixes( szResultBuffer.Get(), "scripts/vscripts/" );
		}

		CStringListTokenizer lstScripts( szResultBuffer.Get() );
		while ( char const *szEntry = lstScripts.NextToken() )
		{
			lstBrowse.AddTail( szEntry );
		}
	}

	pDlg->Release();

	return true;
}				 


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

	CInstancingHelper::ResolveInstancePath( g_pFullFileSystem, MapFileName, currentValue, CMapInstance::GetInstancePath(), FileName, MAX_PATH );

	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));
	strncpy(szSaveValue, m_kv.GetValue(m_szOldKeyName, NULL), sizeof(szSaveValue) - 1);

	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 )
	{
		CMapClass *pMapClass = (CUtlReference< CMapClass >)m_pObjectList->Element(pos);
		CMapEntity *pEntity = static_cast<CMapEntity *>(pMapClass);
		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 = (CUtlReference< CMapClass >)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 = (CUtlReference< CMapClass >)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 = (CUtlReference< CMapClass >)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 = (CUtlReference< CMapClass >)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 = (CUtlReference< CMapClass >)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();
}