//========= 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 #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(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 (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 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 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*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 *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 (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 { CUtlVectorhelperNames; 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 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 temp( pTemp, m_pObjectList->Count() ); FOR_EACH_OBJ( *m_pObjectList, pos ) { CMapClass *pMapClass = (CUtlReference< CMapClass >)m_pObjectList->Element(pos); CMapEntity *pEntity = static_cast(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(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(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 (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 (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( 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(); }