d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
551 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 29985681a1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '29985681a1'
${ noResults }
source-engine/hammer/op_output.cpp

2516 lines
71 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implements a dialog for editing the input/output connections of a
// list of entities. The connections are displayed in a grid control,
// each row of the grid control representing a connection that is
// common to all entities being edited. For example, given these two ents:
//
// Button01
// OnDamaged Sound01 PlaySound 0 0
// OnPressed Door01 Open 0 0
//
// Button02
// OnPressed Door01 Open 0 0
//
// If these two entities were selected, the grid control would show:
//
// OnPressed Door01 Open 0 0
//
// because it is the only connection that is common to both entities.
// Editing an entry in the grid control modifies the corresponding
// connection in all selected entities.
//
// TODO: persist sort column index, sort directions, and column sizes
// TODO: implement an external mode, where the grid shows all connections to unselected ents
//
//=============================================================================//
#include "stdafx.h"
#include "GlobalFunctions.h"
#include "MapDoc.h"
#include "MapEntity.h"
#include "MapWorld.h"
#include "ObjectProperties.h"
#include "OP_Output.h"
#include "ToolManager.h"
#include "MainFrm.h"
#include "utlrbtree.h"
#include "options.h"
#include ".\op_output.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
#pragma warning( disable : 4355 )
#define ICON_CONN_BAD 0
#define ICON_CONN_GOOD 1
#define ICON_CONN_BAD_GREY 2
#define ICON_CONN_GOOD_GREY 3
const char *PARAM_STRING_NONE = "<none>";
//
// Column indices for the list control.
//
const int ICON_COLUMN = 0;
const int OUTPUT_NAME_COLUMN = 1;
const int TARGET_NAME_COLUMN = 2;
const int INPUT_NAME_COLUMN = 3;
const int PARAMETER_COLUMN = 4;
const int DELAY_COLUMN = 5;
const int ONLY_ONCE_COLUMN = 6;
IMPLEMENT_DYNCREATE(COP_Output, CObjectPage)
BEGIN_MESSAGE_MAP(COP_Output, CObjectPage)
//{{AFX_MSG_MAP(COP_Output)
ON_BN_CLICKED(IDC_ADD, OnAdd)
ON_BN_CLICKED(IDC_DELETE, OnDelete)
ON_BN_CLICKED(IDC_COPY, OnCopy)
ON_WM_SIZE()
ON_BN_CLICKED(IDC_PASTE, OnPaste)
ON_BN_CLICKED(IDC_MARK, OnMark)
ON_BN_CLICKED(IDC_PICK_ENTITY, OnPickEntity)
ON_BN_CLICKED(IDC_PICK_ENTITY_PARAM, OnPickEntityParam)
ON_CBN_SELCHANGE(IDC_EDIT_CONN_INPUT, OnSelChangeInput)
ON_CBN_EDITUPDATE(IDC_EDIT_CONN_INPUT, OnEditUpdateInput)
ON_CBN_SELCHANGE(IDC_EDIT_CONN_OUTPUT, OnSelChangeOutput)
ON_CBN_EDITUPDATE(IDC_EDIT_CONN_OUTPUT, OnEditUpdateOutput)
ON_CBN_SELCHANGE(IDC_EDIT_CONN_PARAM, OnSelChangeParam)
ON_CBN_EDITUPDATE(IDC_EDIT_CONN_PARAM, OnEditUpdateParam)
ON_EN_CHANGE(IDC_EDIT_CONN_DELAY, OnEditDelay)
ON_BN_CLICKED(IDC_EDIT_CONN_FIRE_ONCE, OnFireOnce)
ON_BN_CLICKED(IDC_SHOWHIDDENTARGETS, OnShowHiddenTargetsAsBroken)
ON_WM_DESTROY()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
// ON_CBN_SELCHANGE(IDC_EDIT_CONN_TARGET, OnSelChangeTarget)
// ON_CBN_EDITUPDATE(IDC_EDIT_CONN_TARGET, OnEditUpdateTarget)
//
// Static data.
//
CEntityConnectionList *COP_Output::m_pConnectionBuffer = new CEntityConnectionList;
CImageList *COP_Output::m_pImageList = NULL;
//-----------------------------------------------------------------------------
// Returns true if any of the target entities in the connection list are visible.
//-----------------------------------------------------------------------------
static bool AreAnyTargetEntitiesVisible( CEntityConnectionList *pList )
{
for ( int i=0; i < pList->Count(); i++ )
{
if ( pList->Element(i)->AreAnyTargetEntitiesVisible() )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Compares by delays. Used as a secondary sort by all other columns.
//-----------------------------------------------------------------------------
static int CALLBACK ListCompareDelaysSecondary(COutputConnection *pOutputConn1, COutputConnection *pOutputConn2, SortDirection_t eDirection)
{
CEntityConnectionList *pConnList1 = pOutputConn1->m_pConnList;
CEntityConnectionList *pConnList2 = pOutputConn2->m_pConnList;
CEntityConnection *pConn1 = pConnList1->Element(0);
CEntityConnection *pConn2 = pConnList2->Element(0);
return CEntityConnection::CompareDelaysSecondary(pConn1,pConn2,eDirection);
}
//-----------------------------------------------------------------------------
// Purpose: Compares by delays, does a secondary compare by output name.
//-----------------------------------------------------------------------------
static int CALLBACK ListCompareDelays(COutputConnection *pOutputConn1, COutputConnection *pOutputConn2, SortDirection_t eDirection)
{
CEntityConnectionList *pConnList1 = pOutputConn1->m_pConnList;
CEntityConnectionList *pConnList2 = pOutputConn2->m_pConnList;
CEntityConnection *pConn1 = pConnList1->Element(0);
CEntityConnection *pConn2 = pConnList2->Element(0);
return CEntityConnection::CompareDelays(pConn1,pConn2,eDirection);
}
//-----------------------------------------------------------------------------
// Purpose: Compares by output name, does a secondary compare by delay.
//-----------------------------------------------------------------------------
static int CALLBACK ListCompareOutputNames(COutputConnection *pOutputConn1, COutputConnection *pOutputConn2, SortDirection_t eDirection)
{
CEntityConnectionList *pConnList1 = pOutputConn1->m_pConnList;
CEntityConnectionList *pConnList2 = pOutputConn2->m_pConnList;
CEntityConnection *pConn1 = pConnList1->Element(0);
CEntityConnection *pConn2 = pConnList2->Element(0);
return CEntityConnection::CompareOutputNames(pConn1,pConn2,eDirection);
}
//-----------------------------------------------------------------------------
// Purpose: Compares by input name, does a secondary compare by delay.
//-----------------------------------------------------------------------------
static int CALLBACK ListCompareInputNames(COutputConnection *pOutputConn1, COutputConnection *pOutputConn2, SortDirection_t eDirection)
{
CEntityConnectionList *pConnList1 = pOutputConn1->m_pConnList;
CEntityConnectionList *pConnList2 = pOutputConn2->m_pConnList;
CEntityConnection *pConn1 = pConnList1->Element(0);
CEntityConnection *pConn2 = pConnList2->Element(0);
return (CEntityConnection::CompareInputNames(pConn1,pConn2,eDirection));
}
//-----------------------------------------------------------------------------
// Purpose: Compares by source name, does a secondary compare by delay.
//-----------------------------------------------------------------------------
static int CALLBACK ListCompareSourceNames(COutputConnection *pOutputConn1, COutputConnection *pOutputConn2, SortDirection_t eDirection)
{
CEntityConnectionList *pConnList1 = pOutputConn1->m_pConnList;
CEntityConnectionList *pConnList2 = pOutputConn2->m_pConnList;
CEntityConnection *pConn1 = pConnList1->Element(0);
CEntityConnection *pConn2 = pConnList2->Element(0);
return (CEntityConnection::CompareSourceNames(pConn1,pConn2,eDirection));
}
//-----------------------------------------------------------------------------
// Purpose: Compares by target name, does a secondary compare by delay.
//-----------------------------------------------------------------------------
static int CALLBACK ListCompareTargetNames(COutputConnection *pOutputConn1, COutputConnection *pOutputConn2, SortDirection_t eDirection)
{
CEntityConnectionList *pConnList1 = pOutputConn1->m_pConnList;
CEntityConnectionList *pConnList2 = pOutputConn2->m_pConnList;
CEntityConnection *pConn1 = pConnList1->Element(0);
CEntityConnection *pConn2 = pConnList2->Element(0);
return (CEntityConnection::CompareTargetNames(pConn1,pConn2,eDirection));
}
//-----------------------------------------------------------------------------
// Purpose: Called by the entity picker tool when an entity is picked. This
// stuffs the entity name into the smartedit control.
//-----------------------------------------------------------------------------
void COP_OutputPickEntityTarget::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 *pszName = pEntity->GetKeyValue("targetname");
if (!pszName)
{
pszName = "";
}
switch ( m_nDlgItem )
{
case IDC_EDIT_CONN_TARGET:
{
// FIXME: this should be called automatically, but it isn't
m_pDlg->m_ComboTarget.SelectItem(pszName);
break;
}
case IDC_EDIT_CONN_PARAM:
{
// FIXME: this should be called automatically, but it isn't
m_pDlg->GetDlgItem(m_nDlgItem)->SetWindowText(pszName);
m_pDlg->OnEditUpdateParam();
break;
}
default:
{
m_pDlg->GetDlgItem(m_nDlgItem)->SetWindowText(pszName);
break;
}
}
}
m_pDlg->StopPicking();
}
//-----------------------------------------------------------------------------
// Purpose: Constructor.
//-----------------------------------------------------------------------------
COP_Output::COP_Output(void)
: CObjectPage(COP_Output::IDD), m_ComboTarget( this )
{
m_bIgnoreTextChanged = false;
m_pObjectList = NULL;
m_pEditObjectRuntimeClass = RUNTIME_CLASS(editCMapClass);
m_nSortColumn = OUTPUT_NAME_COLUMN;
m_pMapEntityList = NULL;
m_fDelay = 0;
m_bPickingEntities = false;
bSkipEditControlRefresh = false;
//
// All columns initially sort in ascending order.
//
for (int i = 0; i < OUTPUT_LIST_NUM_COLUMNS; i++)
{
m_eSortDirection[i] = Sort_Ascending;
}
m_PickEntityTarget.AttachEntityDlg(this);
}
//-----------------------------------------------------------------------------
// Purpose: Destructor.
//-----------------------------------------------------------------------------
COP_Output::~COP_Output(void)
{
}
void COP_Output::OnTextChanged( const char *pText )
{
if ( m_bIgnoreTextChanged )
return;
// Updating the listbox data, will trigger the edit
// controls to update. They don't need to be
bSkipEditControlRefresh = true;
// Target has changed so we need to update for list of inputs
// that are valid for this target
FillInputList();
FilterInputList();
m_ComboInput.SetWindowText(m_strInput);
UpdateEditedTargets();
}
//------------------------------------------------------------------------------
// Purpose: Updates the validity flag on the given item in the list control
// Input : nItem -
//------------------------------------------------------------------------------
void COP_Output::UpdateItemValidity(int nItem)
{
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
CEntityConnectionList *pConnectionList = pOutputConn->m_pConnList;
bool bShared = (m_EntityList.Count() == pConnectionList->Count());
bool bShowHiddenTargets = ShouldShowHiddenTargets();
int nIcon;
if (ValidateConnections(pOutputConn, bShowHiddenTargets))
{
if ( !bShowHiddenTargets && !AreAnyTargetEntitiesVisible( pConnectionList ) )
nIcon = ICON_CONN_GOOD_GREY;
else if ( bShared )
nIcon = ICON_CONN_GOOD;
else
nIcon = ICON_CONN_GOOD_GREY;
pOutputConn->m_bIsValid = true;
}
else
{
nIcon = (bShared ? ICON_CONN_BAD : ICON_CONN_BAD_GREY);
pOutputConn->m_bIsValid = false;
}
m_ListCtrl.SetItem(nItem,0,LVIF_IMAGE, 0, nIcon, 0, 0, 0 );
}
//------------------------------------------------------------------------------
// Purpose :
//------------------------------------------------------------------------------
void COP_Output::UpdateValidityButton(void)
{
CObjectProperties *pParent = (CObjectProperties*) GetParent();
// Get status of all connections
int nItemCount = m_ListCtrl.GetItemCount();
if (nItemCount == 0)
{
pParent->SetOutputButtonState(CONNECTION_NONE);
return;
}
for (int nItem = 0; nItem < nItemCount; nItem++)
{
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
if (!pOutputConn->m_bIsValid)
{
pParent->SetOutputButtonState(CONNECTION_BAD);
return;
}
}
pParent->SetOutputButtonState(CONNECTION_GOOD);
}
//------------------------------------------------------------------------------
// Purpose: Return true if all connections entries are valid for the given
// output connection. Return false otherwise
//------------------------------------------------------------------------------
bool COP_Output::ValidateConnections(COutputConnection *pOutputConn, bool bVisibilityCheck)
{
int nCount = pOutputConn->m_pConnList->Count();
for (int i = 0; i < nCount; i++)
{
CEntityConnection *pConnection = pOutputConn->m_pConnList->Element(i);
if (pConnection != NULL)
{
// Check validity of output for the list of entities
if (!CEntityConnection::ValidateOutput(pOutputConn->m_pEntityList,pConnection->GetOutputName()))
{
return false;
}
// Check validity of target entity (is it in the map?)
if (!CEntityConnection::ValidateTarget(m_pMapEntityList, bVisibilityCheck, pConnection->GetTargetName()))
{
return false;
}
// Check validity of input
if (!CEntityConnection::ValidateInput(pConnection->GetTargetName(), pConnection->GetInputName(), bVisibilityCheck))
{
return false;
}
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pEntity -
// bFirst -
//-----------------------------------------------------------------------------
void COP_Output::AddEntityConnections(CMapEntity *pEntity, bool bFirst)
{
m_ListCtrl.SetRedraw(FALSE);
//
// The first entity simply adds its connections to the list.
//
int nConnCount = pEntity->Connections_GetCount();
for (int i = 0; i < nConnCount; i++)
{
CEntityConnection *pConnection = pEntity->Connections_Get(i);
if (pConnection != NULL)
{
// First check if the connection already exists, if so just add to it
bool bFound = false;
int nItemCount = m_ListCtrl.GetItemCount();
if (nItemCount > 0)
{
for (int nItem = nItemCount - 1; nItem >= 0; nItem--)
{
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
CEntityConnectionList *pConnList = pOutputConn->m_pConnList;
CEntityConnection *pTestConn = pConnList->Element(0);
if (pTestConn->CompareConnection(pConnection))
{
// Don't consolidate duplicate connections in the same entity
// Show them twice so the user will see
if ( pOutputConn->m_pEntityList->Find(pEntity) == -1)
{
pConnList->AddToTail(pConnection);
pOutputConn->m_pEntityList->AddToTail(pEntity);
bFound = true;
break;
}
}
}
}
if (!bFound)
{
m_ListCtrl.SetItemCount(nItemCount + 1);
m_ListCtrl.InsertItem(LVIF_IMAGE, nItemCount, "", 0, 0, ICON_CONN_GOOD, 0);
m_ListCtrl.SetItemText(nItemCount, OUTPUT_NAME_COLUMN, pConnection->GetOutputName());
m_ListCtrl.SetItemText(nItemCount, TARGET_NAME_COLUMN, pConnection->GetTargetName());
m_ListCtrl.SetItemText(nItemCount, INPUT_NAME_COLUMN, pConnection->GetInputName());
// Build the string for the delay.
float fDelay = pConnection->GetDelay();
char szTemp[MAX_PATH];
sprintf(szTemp, "%.2f", fDelay);
m_ListCtrl.SetItemText(nItemCount, DELAY_COLUMN, szTemp);
// Fire once
m_ListCtrl.SetItemText(nItemCount, ONLY_ONCE_COLUMN, (pConnection->GetTimesToFire() == EVENT_FIRE_ALWAYS) ? "No" : "Yes");
m_ListCtrl.SetItemText(nItemCount, PARAMETER_COLUMN, pConnection->GetParam());
// Set list ctrl data
COutputConnection* pOutputConn = new COutputConnection;
pOutputConn->m_pConnList = new CEntityConnectionList;
pOutputConn->m_pEntityList = new CMapEntityList;
pOutputConn->m_pConnList->AddToTail(pConnection);
pOutputConn->m_pEntityList->AddToTail(pEntity);
pOutputConn->m_bOwnedByAll = true;
m_ListCtrl.SetItemData(nItemCount, (DWORD)pOutputConn);
nItemCount++;
}
}
}
m_ListCtrl.SetRedraw(TRUE);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pDX -
//-----------------------------------------------------------------------------
void COP_Output::DoDataExchange(CDataExchange *pDX)
{
CObjectPage::DoDataExchange(pDX);
//{{AFX_DATA_MAP(COP_Output)
DDX_Control(pDX, IDC_LIST, m_ListCtrl);
DDX_Text(pDX, IDC_EDIT_CONN_DELAY, m_fDelay);
DDX_CBString(pDX, IDC_EDIT_CONN_OUTPUT, m_strOutput);
DDX_CBString(pDX, IDC_EDIT_CONN_TARGET, m_strTarget);
DDX_CBString(pDX, IDC_EDIT_CONN_INPUT, m_strInput);
DDX_CBString(pDX, IDC_EDIT_CONN_PARAM, m_strParam);
DDX_Check(pDX, IDC_EDIT_CONN_FIRE_ONCE, m_bFireOnce);
DDX_Control(pDX, IDC_SHOWHIDDENTARGETS, m_ctlShowHiddenTargetsAsBroken);
DDX_Control(pDX, IDC_ADD, m_AddControl);
DDX_Control(pDX, IDC_PASTE, m_PasteControl);
DDX_Control(pDX, IDC_DELETE, m_DeleteControl);
//}}AFX_DATA_MAP
}
bool COP_Output::ShouldShowHiddenTargets()
{
return (Options.general.bShowHiddenTargetsAsBroken == TRUE);
}
//------------------------------------------------------------------------------
// Purpose: Enables or Disables all edit controls
// Input : bValue -
//------------------------------------------------------------------------------
void COP_Output::EnableEditControls(bool bValue)
{
m_ComboOutput.EnableWindow(bValue);
EnableTarget(bValue);
m_ComboInput.EnableWindow(bValue);
CButton *pButton = (CButton *)GetDlgItem(IDC_EDIT_CONN_FIRE_ONCE);
pButton->EnableWindow(bValue);
CEdit *pDelayEdit = (CEdit *)GetDlgItem(IDC_EDIT_CONN_DELAY);
pDelayEdit->EnableWindow(bValue);
CComboBox *pParamCombo = (CComboBox *)GetDlgItem(IDC_EDIT_CONN_PARAM);
pParamCombo->EnableWindow(bValue);
GetDlgItem(IDC_PICK_ENTITY_PARAM)->EnableWindow( bValue );
// Clear any values
if (!bValue)
{
m_ComboTarget.ForceEditControlText( "" );
m_ComboInput.SetWindowText("");
m_ComboOutput.SetWindowText("");
pParamCombo->SetCurSel(0);
pDelayEdit->SetWindowText("0.0");
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pMapEntityList -
//-----------------------------------------------------------------------------
void COP_Output::SetMapEntityList(const CMapEntityList *pMapEntityList)
{
m_pMapEntityList = pMapEntityList;
FillTargetList();
}
//------------------------------------------------------------------------------
// Purpose: Updates data displayed in edit controls
//------------------------------------------------------------------------------
void COP_Output::UpdateEditControls(void)
{
//
// Build a list of connections to edit.
//
m_EditList.RemoveAll();
m_AddControl.EnableWindow( ( m_bCanEdit ? TRUE : FALSE ) );
m_PasteControl.EnableWindow( ( m_bCanEdit ? TRUE : FALSE ) );
m_DeleteControl.EnableWindow( ( m_bCanEdit ? TRUE : FALSE ) );
// If nothing is selected, disable edit controls
if (!m_ListCtrl.IsWindowEnabled() || m_ListCtrl.GetSelectedCount() == 0)
{
EnableEditControls(false);
return;
}
for (int nItem = 0; nItem < m_ListCtrl.GetItemCount(); nItem++)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
m_EditList.AddVectorToTail(*pOutputConn->m_pConnList);
}
}
if (m_EditList.Count() > 0)
{
SetConnection(&m_EditList);
FillOutputList();
FillInputList();
// We must ignore the text changed event here or else it'll set all selected outputs to the same value.
m_bIgnoreTextChanged = true;
m_ComboTarget.SelectItem(m_strTarget);
m_bIgnoreTextChanged = false;
m_ComboInput.SetWindowText(m_strInput);
m_ComboOutput.SetWindowText(m_strOutput);
m_CheckBoxFireOnce.SetCheck(m_bFireOnce);
CEdit *pDelayEdit = ( CEdit* )GetDlgItem( IDC_EDIT_CONN_DELAY );
char szTemp[MAX_PATH];
sprintf(szTemp, "%.2f", m_fDelay);
pDelayEdit->SetWindowText(szTemp);
CComboBox* pParamEdit = ( CComboBox* )GetDlgItem( IDC_EDIT_CONN_PARAM );
pParamEdit->SetWindowText(m_strParam);
FilterInputList();
//
// Update the UI state based on our current data.
//
char szBuf[MAX_IO_NAME_LEN];
CClassOutput *pOutput = GetOutput(szBuf, sizeof(szBuf));
UpdateCombosForSelectedOutput(pOutput);
CClassInput *pInput = GetInput(szBuf, sizeof(szBuf));
UpdateCombosForSelectedInput(pInput);
//CMapEntityList *pTarget = GetTarget(szBuf, sizeof(szBuf));
//UpdateCombosForSelectedTarget(pTarget);
}
if ( m_bCanEdit == false )
{
EnableEditControls( false );
}
}
//-----------------------------------------------------------------------------
// Purpose: Adds a connection to all entities being edited.
//-----------------------------------------------------------------------------
void COP_Output::OnAdd(void)
{
FOR_EACH_OBJ( m_EntityList, pos)
{
CMapEntity *pEntity = m_EntityList.Element(pos);
if (pEntity != NULL)
{
CEntityConnection *pConnection = new CEntityConnection;
pEntity->Connections_Add(pConnection);
}
}
UpdateConnectionList();
// Set selection to new item, and move the focus to the output combo
// so they can just start editing.
int nCount = m_ListCtrl.GetItemCount();
SetSelectedItem(nCount - 1);
m_ListCtrl.EnsureVisible(nCount - 1, FALSE);
GetDlgItem(IDC_EDIT_CONN_OUTPUT)->SetFocus();
}
//------------------------------------------------------------------------------
// Purpose: Clear copy buffer
//------------------------------------------------------------------------------
void COP_Output::EmptyCopyBuffer(void)
{
// Delete any old connections
int nConnCount = m_pConnectionBuffer->Count();
for (int i = 0; i < nConnCount; i++)
{
CEntityConnection *pConnection = m_pConnectionBuffer->Element(i);
if (pConnection != NULL)
{
delete pConnection;
}
}
m_pConnectionBuffer->RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose: Copies list of selected connections into copy buffer
//-----------------------------------------------------------------------------
void COP_Output::OnCopy(void)
{
EmptyCopyBuffer();
if (m_ListCtrl.GetSelectedCount() != 0)
{
int nCount = m_ListCtrl.GetItemCount();
if (nCount > 0)
{
for (int nItem = nCount - 1; nItem >= 0; nItem--)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
//
// Each item in the list control is a list of identical connections that are contained
// in multiple entities. Add each selected connection to the selected entities.
//
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
CEntityConnectionList *pConnList = pOutputConn->m_pConnList;
if (pConnList != NULL)
{
CEntityConnection *pConnection = pConnList->Element(0);
if (pConnection)
{
CEntityConnection *pNewConnection = new CEntityConnection;
*pNewConnection = *pConnection;
m_pConnectionBuffer->AddToTail(pNewConnection);
}
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Adds a connection to all entities being edited.
//-----------------------------------------------------------------------------
void COP_Output::OnPaste(void)
{
// Early out
if (!m_pConnectionBuffer->Count())
{
return;
}
CUtlVector<CEntityConnection *> NewConnections;
// Add connections from copy buffer to all selected entities
FOR_EACH_OBJ( m_EntityList, pos )
{
CMapEntity *pEntity = m_EntityList.Element(pos);
if (pEntity != NULL)
{
int nConnCount = m_pConnectionBuffer->Count();
for (int i = 0; i < nConnCount; i++)
{
CEntityConnection *pConnection = m_pConnectionBuffer->Element(i);
if (pConnection != NULL)
{
CEntityConnection *pNewConnection = new CEntityConnection;
*pNewConnection = *pConnection;
pEntity->Connections_Add(pNewConnection);
NewConnections.AddToTail(pNewConnection);
}
}
}
}
UpdateConnectionList();
SortListByColumn(m_nSortColumn, m_eSortDirection[m_nSortColumn]);
SetSelectedConnections(NewConnections);
GetDlgItem(IDC_EDIT_CONN_OUTPUT)->SetFocus();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COP_Output::OnPickEntity(void)
{
CButton *pButton = (CButton *)GetDlgItem(IDC_PICK_ENTITY);
Assert(pButton != NULL);
if (pButton != NULL)
{
if (pButton->GetCheck())
{
//
// Activate the entity picker tool.
//
m_bPickingEntities = true;
m_PickEntityTarget.AttachDlgItem( IDC_EDIT_CONN_TARGET );
CToolPickEntity *pTool = (CToolPickEntity *)ToolManager()->GetToolForID(TOOL_PICK_ENTITY);
pTool->Attach(&m_PickEntityTarget);
ToolManager()->SetTool(TOOL_PICK_ENTITY);
GetDlgItem(IDC_PICK_ENTITY_PARAM)->EnableWindow( false );
}
else
{
StopPicking();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COP_Output::OnPickEntityParam(void)
{
CButton *pButton = (CButton *)GetDlgItem(IDC_PICK_ENTITY_PARAM);
Assert(pButton != NULL);
if (pButton != NULL)
{
if (pButton->GetCheck())
{
//
// Activate the entity picker tool.
//
m_bPickingEntities = true;
m_PickEntityTarget.AttachDlgItem( IDC_EDIT_CONN_PARAM );
CToolPickEntity *pTool = (CToolPickEntity *)ToolManager()->GetToolForID(TOOL_PICK_ENTITY);
pTool->Attach(&m_PickEntityTarget);
ToolManager()->SetTool(TOOL_PICK_ENTITY);
GetDlgItem(IDC_PICK_ENTITY)->EnableWindow( false );
}
else
{
StopPicking();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Deletes all selected items from the connection list, and removes the
// corresponding connections from the list of entities being edited.
//-----------------------------------------------------------------------------
void COP_Output::OnDelete(void)
{
if (m_ListCtrl.GetSelectedCount() != 0)
{
int nCount = m_ListCtrl.GetItemCount();
int nLastItem = 0;
if (nCount > 0)
{
for (int nItem = nCount - 1; nItem >= 0; nItem--)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
//
// Each item in the list control is a list of identical connections that are contained
// in multiple entities. Since we don't store the containing entity along with the connection,
// just try to remove all the connections in the list from all the selected entities.
//
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
CEntityConnectionList *pConnList = pOutputConn->m_pConnList;
m_ListCtrl.DeleteItem(nItem);
if (pConnList != NULL)
{
int nConnCount = pConnList->Count();
for (int nConn = 0; nConn < nConnCount; nConn++)
{
CEntityConnection *pConnection = pConnList->Element(nConn);
if (pConnection != NULL)
{
//
// Remove the connection from all entities being edited.
//
FOR_EACH_OBJ( m_EntityList, pos )
{
CMapEntity *pEntity = m_EntityList.Element(pos);
if (pEntity != NULL)
{
pEntity->Connections_Remove(pConnection);
}
}
//
// Remove the connection from the upstream list of all entities it targets.
//
CMapEntityList *pTargetList = pConnection->GetTargetEntityList();
if ( pTargetList )
{
FOR_EACH_OBJ( *pTargetList, pos2 )
{
CMapEntity *pEntity = pTargetList->Element( pos2 );
pEntity->Upstream_Remove( pConnection );
}
}
}
delete pConnection;
}
delete pConnList;
}
// Keep track of last item so can set selection focus
nLastItem = nItem;
}
}
}
// Set selection focus as point of deletion or on last item
int nNumItems = m_ListCtrl.GetItemCount()-1;
if (nLastItem > nNumItems)
{
nLastItem = nNumItems;
}
SetSelectedItem(nLastItem);
UpdateValidityButton();
}
}
//------------------------------------------------------------------------------
// Purpose : Take the user to the output page of the selected entity that
// targets me.
// Input :
// Output :
//------------------------------------------------------------------------------
void COP_Output::OnMark(void)
{
int nCount = m_ListCtrl.GetItemCount();
CMapDoc* pDoc = CMapDoc::GetActiveMapDoc();
CEntityConnection *pConnection = NULL;
if (nCount > 0 && pDoc)
{
CMapObjectList Select;
for (int nItem = nCount - 1; nItem >= 0; nItem--)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
pConnection = pOutputConn->m_pConnList->Element(0);
CMapDoc *pDocActive = CMapDoc::GetActiveMapDoc();
if ( pDocActive != NULL)
{
CMapEntityList Found;
pDocActive->FindEntitiesByName(Found, m_ListCtrl.GetItemText(nItem, TARGET_NAME_COLUMN), false);
FOR_EACH_OBJ( Found, pos )
{
CMapEntity *pEntity = Found.Element(pos);
Select.AddToTail(pEntity);
}
}
}
}
if (Select.Count()>0)
{
pDoc->SelectObjectList(&Select);
// (a bit squirly way of doing this)
if ( Select.Count()==1 )
GetMainWnd()->pObjectProperties->SetPageToInput(pConnection);
pDoc->Center2DViewsOnSelection();
}
else
{
MessageBox("No entities were found with that targetname.", "No entities found", MB_ICONINFORMATION | MB_OK);
return;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets up the list view columns, initial sort column.
//-----------------------------------------------------------------------------
BOOL COP_Output::OnInitDialog(void)
{
CObjectPage::OnInitDialog();
m_ComboOutput.SubclassDlgItem(IDC_EDIT_CONN_OUTPUT, this);
m_ComboInput.SubclassDlgItem(IDC_EDIT_CONN_INPUT, this);
m_ComboTarget.SubclassDlgItem(IDC_EDIT_CONN_TARGET, this);
m_CheckBoxFireOnce.SubclassDlgItem(IDC_EDIT_CONN_FIRE_ONCE, this);
m_ListCtrl.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_HEADERDRAGDROP);
m_ListCtrl.InsertColumn(ICON_COLUMN, "", LVCFMT_CENTER, 20);
m_ListCtrl.InsertColumn(OUTPUT_NAME_COLUMN, "My Output", LVCFMT_LEFT, 70);
m_ListCtrl.InsertColumn(TARGET_NAME_COLUMN, "Target Entity", LVCFMT_LEFT, 70);
m_ListCtrl.InsertColumn(INPUT_NAME_COLUMN, "Target Input", LVCFMT_LEFT, 70);
m_ListCtrl.InsertColumn(DELAY_COLUMN, "Delay", LVCFMT_LEFT, 70);
m_ListCtrl.InsertColumn(ONLY_ONCE_COLUMN, "Only Once", LVCFMT_LEFT, 70);
m_ListCtrl.InsertColumn(PARAMETER_COLUMN, "Parameter", LVCFMT_LEFT, 70);
UpdateConnectionList();
SetSortColumn(m_nSortColumn, m_eSortDirection[m_nSortColumn]);
// Force an update of the column header text so that the sort indicator is shown.
UpdateColumnHeaderText(m_nSortColumn, true, m_eSortDirection[m_nSortColumn]);
ResizeColumns();
m_strLastParam.Empty();
// Select the first item in the combo box
SetSelectedItem(0);
// Create image list. Is deleted automatically when listctrl is deleted
if (!m_pImageList)
{
CWinApp *pApp = AfxGetApp();
m_pImageList = new CImageList();
Assert(m_pImageList != NULL); // serious allocation failure checking
m_pImageList->Create(16, 16, TRUE, 1, 0);
m_pImageList->Add(pApp->LoadIcon( IDI_OUTPUTBAD ));
m_pImageList->Add(pApp->LoadIcon( IDI_OUTPUT ));
m_pImageList->Add(pApp->LoadIcon( IDI_OUTPUTBAD_GREY ));
m_pImageList->Add(pApp->LoadIcon( IDI_OUTPUT_GREY ));
}
m_ListCtrl.SetImageList(m_pImageList, LVSIL_SMALL );
// Apply the eyedropper image to the picker buttons.
CButton *pButton = (CButton *)GetDlgItem(IDC_PICK_ENTITY);
if (pButton)
{
CWinApp *pApp = AfxGetApp();
HICON hIcon = pApp->LoadIcon(IDI_EYEDROPPER);
pButton->SetIcon(hIcon);
}
pButton = (CButton *)GetDlgItem(IDC_PICK_ENTITY_PARAM);
if (pButton)
{
CWinApp *pApp = AfxGetApp();
HICON hIcon = pApp->LoadIcon(IDI_EYEDROPPER);
pButton->SetIcon(hIcon);
}
CAnchorDef anchorDefs[] =
{
CAnchorDef( IDC_LIST, k_eSimpleAnchorAllSides ),
CAnchorDef( IDC_OUTPUTS_STATIC_PANEL, k_eAnchorLeft, k_eAnchorBottom, k_eAnchorRight, k_eAnchorBottom ),
CAnchorDef( IDC_OUTPUT_LABEL, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_TARGETS_LABEL, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_VIA_INPUT_LABEL, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_PARAMETER_LABEL, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_DELAY_LABEL, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_EDIT_CONN_DELAY, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_EDIT_CONN_FIRE_ONCE, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_EDIT_CONN_PARAM, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_EDIT_CONN_INPUT, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_EDIT_CONN_TARGET, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_EDIT_CONN_OUTPUT, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_PICK_ENTITY, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_PICK_ENTITY_PARAM, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_MARK, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_ADD, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_COPY, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_PASTE, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_DELETE, k_eSimpleAnchorBottomSide ),
CAnchorDef( IDC_SHOWHIDDENTARGETS, k_eSimpleAnchorBottomRight )
};
m_AnchorMgr.Init( GetSafeHwnd(), anchorDefs, ARRAYSIZE( anchorDefs ) );
// Set the last state this was at.
m_ctlShowHiddenTargetsAsBroken.SetCheck( ShouldShowHiddenTargets() );
return(TRUE);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : wParam -
// lParam -
// pResult -
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL COP_Output::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT *pResult)
{
NMHDR *pnmh = (NMHDR *)lParam;
if (pnmh->idFrom == IDC_LIST)
{
switch (pnmh->code)
{
case LVN_COLUMNCLICK:
{
NMLISTVIEW *pnmv = (NMLISTVIEW *)lParam;
if (pnmv->iSubItem < OUTPUT_LIST_NUM_COLUMNS)
{
SortDirection_t eSortDirection = m_eSortDirection[pnmv->iSubItem];
//
// If they clicked on the current sort column, reverse the sort direction.
//
if (pnmv->iSubItem == m_nSortColumn)
{
if (m_eSortDirection[m_nSortColumn] == Sort_Ascending)
{
eSortDirection = Sort_Descending;
}
else
{
eSortDirection = Sort_Ascending;
}
}
//
// Update the sort column and sort the list.
//
SetSortColumn(pnmv->iSubItem, eSortDirection);
}
return(TRUE);
}
case NM_DBLCLK:
{
OnMark();
return(TRUE);
}
case LVN_ITEMCHANGED:
{
NMLISTVIEW *pnmv = (NMLISTVIEW *)lParam;
if ( ( pnmv->uNewState & LVIS_SELECTED ) != ( pnmv->uOldState & LVIS_SELECTED ) )
{
// Listbox selection has changed so update edit controls
if (!bSkipEditControlRefresh)
{
UpdateEditControls();
}
bSkipEditControlRefresh = false;
// Forget the saved param, because it was for a different I/O connection.
m_strLastParam.Empty();
}
return(TRUE);
}
}
}
return(CObjectPage::OnNotify(wParam, lParam, pResult));
}
//-----------------------------------------------------------------------------
// Purpose: Empties the contents of the connections list control, freeing the
// connection list hanging off of each row.
//-----------------------------------------------------------------------------
void COP_Output::RemoveAllEntityConnections(void)
{
m_ListCtrl.SetRedraw(FALSE);
int nCount = m_ListCtrl.GetItemCount();
if (nCount > 0)
{
for (int nItem = nCount - 1; nItem >= 0; nItem--)
{
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
CEntityConnectionList *pConnList = pOutputConn->m_pConnList;
CMapEntityList *pEntityList = pOutputConn->m_pEntityList;
m_ListCtrl.DeleteItem(nItem);
delete pOutputConn;
delete pConnList;
delete pEntityList;
}
}
m_ListCtrl.SetRedraw(TRUE);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : Mode -
// pData -
//-----------------------------------------------------------------------------
void COP_Output::UpdateData( int Mode, PVOID pData, bool bCanEdit )
{
__super::UpdateData( Mode, pData, bCanEdit );
if (!IsWindow(m_hWnd))
{
return;
}
switch (Mode)
{
case LoadFirstData:
{
// m_ListCtrl.DeleteAllItems();
// UpdateConnectionList();
break;
}
case LoadData:
{
// m_ListCtrl.DeleteAllItems();
// UpdateConnectionList();
// SetSelectedItem(0);
break;
}
case LoadFinished:
{
m_ListCtrl.DeleteAllItems();
UpdateConnectionList();
SetSelectedItem(0);
SortListByColumn(m_nSortColumn, m_eSortDirection[m_nSortColumn]);
}
}
UpdateEditControls();
}
//------------------------------------------------------------------------------
// Purpose: Generates list of map entites that are being edited from the
// m_pObject list
//------------------------------------------------------------------------------
void COP_Output::UpdateEntityList(void)
{
// Clear old entity list
m_EntityList.RemoveAll();
if (m_pObjectList != NULL)
{
FOR_EACH_OBJ( *m_pObjectList, pos )
{
CMapClass *pObject = m_pObjectList->Element(pos);
if ((pObject != NULL) && (pObject->IsMapClass(MAPCLASS_TYPE(CMapEntity))) )
{
CMapEntity *pEntity = (CMapEntity *)pObject;
m_EntityList.AddToTail(pEntity);
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nColumn -
// eDirection -
//-----------------------------------------------------------------------------
void COP_Output::SetSortColumn(int nColumn, SortDirection_t eDirection)
{
Assert(nColumn < OUTPUT_LIST_NUM_COLUMNS);
//
// If the sort column changed, update the old sort column header text.
//
if (m_nSortColumn != nColumn)
{
UpdateColumnHeaderText(m_nSortColumn, false, eDirection);
}
//
// If the sort column or direction changed, update the new sort column header text.
//
if ((m_nSortColumn != nColumn) || (m_eSortDirection[m_nSortColumn] != eDirection))
{
UpdateColumnHeaderText(nColumn, true, eDirection);
}
m_nSortColumn = nColumn;
m_eSortDirection[m_nSortColumn] = eDirection;
SortListByColumn(m_nSortColumn, m_eSortDirection[m_nSortColumn]);
}
//-----------------------------------------------------------------------------
// Purpose: Sorts the outputs list by column.
// Input : nColumn - Index of column by which to sort.
//-----------------------------------------------------------------------------
void COP_Output::SortListByColumn(int nColumn, SortDirection_t eDirection)
{
PFNLVCOMPARE pfnSort = NULL;
switch (nColumn)
{
case ONLY_ONCE_COLUMN:
{
//No Sort
break;
}
case PARAMETER_COLUMN:
{
//No Sort
break;
}
case OUTPUT_NAME_COLUMN:
{
pfnSort = (PFNLVCOMPARE)ListCompareOutputNames;
break;
}
case TARGET_NAME_COLUMN:
{
pfnSort = (PFNLVCOMPARE)ListCompareTargetNames;
break;
}
case INPUT_NAME_COLUMN:
{
pfnSort = (PFNLVCOMPARE)ListCompareInputNames;
break;
}
case DELAY_COLUMN:
{
pfnSort = (PFNLVCOMPARE)ListCompareDelays;
break;
}
default:
{
Assert(FALSE);
break;
}
}
if (pfnSort != NULL)
{
m_ListCtrl.SortItems(pfnSort, (DWORD)eDirection);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COP_Output::ResizeColumns(void)
{
if (m_ListCtrl.GetItemCount() > 0)
{
m_ListCtrl.SetColumnWidth(OUTPUT_NAME_COLUMN, LVSCW_AUTOSIZE);
m_ListCtrl.SetColumnWidth(TARGET_NAME_COLUMN, LVSCW_AUTOSIZE);
m_ListCtrl.SetColumnWidth(INPUT_NAME_COLUMN, LVSCW_AUTOSIZE);
m_ListCtrl.SetColumnWidth(DELAY_COLUMN, LVSCW_AUTOSIZE_USEHEADER);
m_ListCtrl.SetColumnWidth(ONLY_ONCE_COLUMN, LVSCW_AUTOSIZE_USEHEADER);
m_ListCtrl.SetColumnWidth(PARAMETER_COLUMN, LVSCW_AUTOSIZE);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COP_Output::UpdateConnectionList(void)
{
// Get list of all entities in the world
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
Assert(pDoc != NULL);
if (!pDoc)
return;
CMapWorld *pWorld = pDoc->GetMapWorld();
Assert(pWorld != NULL); // dvs: I've seen pWorld be NULL on app shutdown, not sure why we ended up here though
if (!pWorld)
return;
SetMapEntityList(pWorld->EntityList_GetList());
UpdateEntityList();
RemoveAllEntityConnections();
bool bFirst = true;
FOR_EACH_OBJ( m_EntityList, pos )
{
CMapEntity *pEntity = m_EntityList.Element(pos);
if (pEntity != NULL)
{
AddEntityConnections(pEntity, bFirst);
bFirst = false;
}
}
// Update validity flag on all items
for (int nItem = 0; nItem < m_ListCtrl.GetItemCount(); nItem++)
{
UpdateItemValidity(nItem);
}
UpdateValidityButton();
ResizeColumns();
}
//------------------------------------------------------------------------------
// Purpose: Set the selected item in the listbox by index.
// Input : nSelectItem -
//------------------------------------------------------------------------------
void COP_Output::SetSelectedItem(int nSelectItem)
{
m_ListCtrl.SetRedraw(FALSE);
// Set selected item to be active and all others to false
int nItemCount = m_ListCtrl.GetItemCount();
for (int nItem = 0; nItem < nItemCount; nItem++)
{
if (nItem == nSelectItem)
{
m_ListCtrl.SetItemState(nItem, (unsigned int)LVIS_SELECTED, (unsigned int)LVIS_SELECTED);
}
else
{
m_ListCtrl.SetItemState(nItem, (unsigned int)~LVIS_SELECTED, (unsigned int)LVIS_SELECTED);
}
}
m_ListCtrl.SetRedraw(TRUE);
// Selected item has changed so update edit controls
UpdateEditControls();
}
//------------------------------------------------------------------------------
// Purpose: Set the selected item in the listbox
// Input : pConnection
//------------------------------------------------------------------------------
void COP_Output::SetSelectedConnection(CEntityConnection *pConnection)
{
m_ListCtrl.SetRedraw(FALSE);
// Set selected item to be active and all others to false
int nItemCount = m_ListCtrl.GetItemCount();
for (int nItem = 0; nItem < nItemCount; nItem++)
{
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
CEntityConnectionList *pTestList = pOutputConn->m_pConnList;
if (pTestList->Element(0) == pConnection)
{
m_ListCtrl.SetItemState(nItem,LVIS_SELECTED,LVIS_SELECTED);
}
else
{
m_ListCtrl.SetItemState(nItem, (unsigned int)~LVIS_SELECTED, (unsigned int)LVIS_SELECTED);
}
}
m_ListCtrl.SetRedraw(TRUE);
// Selected item has changed so update edit controls
UpdateEditControls();
}
//-----------------------------------------------------------------------------
// Purpose: Selects the list box entries that correspond to the connections in
// the given list.
//-----------------------------------------------------------------------------
void COP_Output::SetSelectedConnections(CEntityConnectionList &List)
{
m_ListCtrl.SetRedraw(FALSE);
int nConnCount = List.Count();
int nItemCount = m_ListCtrl.GetItemCount();
for (int nItem = 0; nItem < nItemCount; nItem++)
{
COutputConnection *pOutputConn = (COutputConnection *)m_ListCtrl.GetItemData(nItem);
CEntityConnectionList *pConnList = pOutputConn->m_pConnList;
// See if this row's list holds any of the connections in the given list.
bool bFound = false;
for (int nConn = 0; nConn < nConnCount; nConn++)
{
CEntityConnection *pConn = List.Element(nConn);
if (pConnList->Find(pConn) != -1)
{
bFound = true;
break;
}
}
m_ListCtrl.SetItemState(nItem, bFound ? LVIS_SELECTED : ~LVIS_SELECTED, LVIS_SELECTED);
}
m_ListCtrl.SetRedraw(TRUE);
UpdateEditControls();
}
//-----------------------------------------------------------------------------
// Purpose: Adds or removes the little 'V' or '^' sort indicator as appropriate.
// Input : nColumn - Index of column to update.
// bSortColumn - true if this column is the sort column, false if not.
// eDirection - Direction of sort, Sort_Ascending or Sort_Descending.
//-----------------------------------------------------------------------------
void COP_Output::UpdateColumnHeaderText(int nColumn, bool bIsSortColumn, SortDirection_t eDirection)
{
char szHeaderText[MAX_PATH];
LVCOLUMN Column;
memset(&Column, 0, sizeof(Column));
Column.mask = LVCF_TEXT;
Column.pszText = szHeaderText;
Column.cchTextMax = sizeof(szHeaderText);
m_ListCtrl.GetColumn(nColumn, &Column);
int nMarker = 0;
if (szHeaderText[0] != '\0')
{
nMarker = strlen(szHeaderText) - 1;
char chMarker = szHeaderText[nMarker];
if ((chMarker == '>') || (chMarker == '<'))
{
nMarker -= 2;
}
else
{
nMarker++;
}
}
if (bIsSortColumn)
{
if (nMarker != 0)
{
szHeaderText[nMarker++] = ' ';
szHeaderText[nMarker++] = ' ';
}
szHeaderText[nMarker++] = (eDirection == Sort_Ascending) ? '>' : '<';
}
szHeaderText[nMarker] = '\0';
m_ListCtrl.SetColumn(nColumn, &Column);
}
//-----------------------------------------------------------------------------
// Purpose: Called when our window is being destroyed.
//-----------------------------------------------------------------------------
void COP_Output::OnDestroy(void)
{
m_ListCtrl.EnableWindow(false);
RemoveAllEntityConnections();
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void COP_Output::UpdateEditedFireOnce(void)
{
// Get new delay
CButton *pButton = ( CButton* )GetDlgItem( IDC_EDIT_CONN_FIRE_ONCE );
if (pButton->IsWindowEnabled())
{
int nChecked = (pButton->GetState()&0x0003); // Checked state
// Update the connections
int nConnCount = m_EditList.Count();
for (int nConn = 0; nConn < nConnCount; nConn++)
{
CEntityConnection *pConnection = m_EditList.Element(nConn);
if (pConnection != NULL)
{
pConnection->SetTimesToFire(nChecked?1:EVENT_FIRE_ALWAYS);
}
}
// Update the list box
for (int nItem = 0; nItem < m_ListCtrl.GetItemCount(); nItem++)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
m_ListCtrl.SetItemText(nItem, ONLY_ONCE_COLUMN, nChecked ? "Yes" : "No");
}
}
ResizeColumns();
}
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void COP_Output::UpdateEditedDelays(void)
{
// Get new delay
CEdit *pDelayEdit = ( CEdit* )GetDlgItem( IDC_EDIT_CONN_DELAY );
if (pDelayEdit->IsWindowEnabled())
{
char strDelay[MAX_IO_NAME_LEN];
pDelayEdit->GetWindowText(strDelay, sizeof(strDelay));
float flDelay = atof(strDelay);
// Update the connections
int nConnCount = m_EditList.Count();
for (int nConn = 0; nConn < nConnCount; nConn++)
{
CEntityConnection *pConnection = m_EditList.Element(nConn);
if (pConnection != NULL)
{
pConnection->SetDelay(flDelay);
}
}
// Update the list box
for (int nItem = 0; nItem < m_ListCtrl.GetItemCount(); nItem++)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
m_ListCtrl.SetItemText(nItem, DELAY_COLUMN, strDelay);
}
}
ResizeColumns();
}
}
//------------------------------------------------------------------------------
// Purpose: Parameters have changed. Update connections and listbox
//------------------------------------------------------------------------------
void COP_Output::UpdateEditedParams(void)
{
CComboBox *pParamEdit = ( CComboBox* )GetDlgItem( IDC_EDIT_CONN_PARAM );
if (pParamEdit->IsWindowEnabled())
{
char strParam[MAX_IO_NAME_LEN];
pParamEdit->GetWindowText(strParam, sizeof(strParam));
if (!strcmp(strParam, PARAM_STRING_NONE))
{
strParam[0] = '\0';
}
// Update the connections
int nConnCount = m_EditList.Count();
for (int nConn = 0; nConn < nConnCount; nConn++)
{
CEntityConnection *pConnection = m_EditList.Element(nConn);
if (pConnection != NULL)
{
pConnection->SetParam(strParam);
}
}
// Update the list box
for (int nItem = 0; nItem < m_ListCtrl.GetItemCount(); nItem++)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
m_ListCtrl.SetItemText(nItem, PARAMETER_COLUMN, strParam);
}
}
ResizeColumns();
}
}
//------------------------------------------------------------------------------
// Purpose: Inputs have changed. Update connections and listbox
//------------------------------------------------------------------------------
void COP_Output::UpdateEditedInputs(void)
{
// Get the new name
char strInput[MAX_IO_NAME_LEN];
GetInput(strInput, sizeof(strInput));
// Update the connections
int nConnCount = m_EditList.Count();
for (int nConn = 0; nConn < nConnCount; nConn++)
{
CEntityConnection *pConnection = m_EditList.Element(nConn);
if (pConnection != NULL)
{
pConnection->SetInputName(strInput);
}
}
// Update the list box
for (int nItem = 0; nItem < m_ListCtrl.GetItemCount(); nItem++)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
m_ListCtrl.SetItemText(nItem, INPUT_NAME_COLUMN, strInput);
UpdateItemValidity(nItem);
}
}
UpdateValidityButton();
ResizeColumns();
}
//------------------------------------------------------------------------------
// Purpose: Outputs have changed. Update connections and listbox
//------------------------------------------------------------------------------
void COP_Output::UpdateEditedOutputs()
{
// Get the new name
char strOutput[MAX_IO_NAME_LEN];
GetOutput(strOutput, sizeof(strOutput));
// Update the connections
int nConnCount = m_EditList.Count();
for (int nConn = 0; nConn < nConnCount; nConn++)
{
CEntityConnection *pConnection = m_EditList.Element(nConn);
if (pConnection != NULL)
{
pConnection->SetOutputName(strOutput);
}
}
// Update the list box
for (int nItem = 0; nItem < m_ListCtrl.GetItemCount(); nItem++)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
m_ListCtrl.SetItemText(nItem, OUTPUT_NAME_COLUMN, strOutput);
UpdateItemValidity(nItem);
}
}
UpdateValidityButton();
ResizeColumns();
}
//------------------------------------------------------------------------------
// Purpose: Targets have changed. Update connections and listbox
//------------------------------------------------------------------------------
void COP_Output::UpdateEditedTargets(void)
{
// Get the new target name
char strTarget[MAX_IO_NAME_LEN];
GetTarget(strTarget, sizeof(strTarget));
// Update the connections
int nConnCount = m_EditList.Count();
for (int nConn = 0; nConn < nConnCount; nConn++)
{
CEntityConnection *pConnection = m_EditList.Element(nConn);
if (pConnection != NULL)
{
pConnection->SetTargetName(strTarget);
}
}
// Update the list box
for (int nItem = 0; nItem < m_ListCtrl.GetItemCount(); nItem++)
{
if (m_ListCtrl.GetItemState(nItem, LVIS_SELECTED) & LVIS_SELECTED)
{
m_ListCtrl.SetItemText(nItem, TARGET_NAME_COLUMN, strTarget);
UpdateItemValidity(nItem);
}
}
UpdateValidityButton();
ResizeColumns();
}
//-----------------------------------------------------------------------------
// Purpose: Enables or diables the target combo box and the eyedropper button.
//-----------------------------------------------------------------------------
void COP_Output::EnableTarget(bool bEnable)
{
m_ComboTarget.EnableWindow(bEnable);
GetDlgItem(IDC_PICK_ENTITY)->EnableWindow(bEnable);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pConnection -
//-----------------------------------------------------------------------------
void COP_Output::SetConnection(CEntityConnectionList *pConnectionList)
{
Assert(pConnectionList != NULL);
// Fill edit boxes. Disable for multiple connections have incompatible data
bool bFirst = true;
CButton* pFireEdit = ( CButton* )GetDlgItem( IDC_EDIT_CONN_FIRE_ONCE );
CEdit* pDelayEdit = ( CEdit* )GetDlgItem( IDC_EDIT_CONN_DELAY );
CComboBox* pParamEdit = ( CComboBox* )GetDlgItem( IDC_EDIT_CONN_PARAM );
m_ComboOutput.EnableWindow(true);
EnableTarget(true);
m_ComboInput.EnableWindow(true);
pFireEdit->EnableWindow(true);
pDelayEdit->EnableWindow(true);
pParamEdit->EnableWindow(true);
GetDlgItem(IDC_PICK_ENTITY_PARAM)->EnableWindow( false );
m_bEntityParamTarget = false;
int nConnCount = pConnectionList->Count();
for (int nConn = 0; nConn < nConnCount; nConn++)
{
CEntityConnection *pConnection = (CEntityConnection *)pConnectionList->Element(nConn);
if (pConnection == NULL)
continue;
// Fill in output name, disable for non-compatible connections
if (m_ComboOutput.IsWindowEnabled())
{
if (bFirst)
{
m_strOutput = pConnection->GetOutputName();
}
else if (m_strOutput != pConnection->GetOutputName())
{
m_strOutput.Empty();
m_ComboOutput.EnableWindow(false);
}
}
// Fill in target name, disable for non-compatible connections
if (m_ComboTarget.IsWindowEnabled())
{
if (bFirst)
{
m_strTarget = pConnection->GetTargetName();
}
else if (m_strTarget != pConnection->GetTargetName())
{
m_strTarget.Empty();
EnableTarget(false);
}
}
// Fill in input name, disable for non-compatible connections
if (m_ComboInput.IsWindowEnabled())
{
if (bFirst)
{
m_strInput = pConnection->GetInputName();
}
else if (m_strInput != pConnection->GetInputName())
{
m_strInput.Empty();
m_ComboInput.EnableWindow(false);
}
}
// Fill in parameters, disable for non-compatible connections
if (pParamEdit->IsWindowEnabled())
{
if (bFirst)
{
m_strParam = pConnection->GetParam();
m_bNoParamEdit = false;
}
else if (m_strParam != pConnection->GetParam())
{
m_strParam.Empty();
pParamEdit->EnableWindow(false);
GetDlgItem(IDC_PICK_ENTITY_PARAM)->EnableWindow( false );
m_bNoParamEdit = true;
}
}
// Fill in delay, disable for non-compatible connections
if (pDelayEdit->IsWindowEnabled())
{
if (bFirst)
{
m_fDelay = pConnection->GetDelay();
}
else if (m_fDelay != pConnection->GetDelay())
{
m_fDelay = 0;
pDelayEdit->EnableWindow(false);
}
}
// Set fire once flag, disable for non-compatible connections
if (pFireEdit->IsWindowEnabled())
{
if (bFirst)
{
m_bFireOnce = (pConnection->GetTimesToFire() == -1) ? false : true;
}
else if (m_bFireOnce != pConnection->GetTimesToFire())
{
m_bFireOnce = false;
pFireEdit->EnableWindow(false);
}
}
bFirst = false;
}
// Put a <none> in param box if no param
if (strlen(m_strParam) == 0)
{
m_strParam = PARAM_STRING_NONE;
}
}
//-----------------------------------------------------------------------------
// Purpose: Adds all of an entity's outputs from its class definition to the
// outputs combo box.
// Input : pEntity - Entity whose outputs are to be added to the combo box.
//-----------------------------------------------------------------------------
void COP_Output::AddEntityOutputs(CMapEntity *pEntity)
{
GDclass *pClass = pEntity->GetClass();
if (pClass != NULL)
{
int nCount = pClass->GetOutputCount();
for (int i = 0; i < nCount; i++)
{
CClassOutput *pOutput = pClass->GetOutput(i);
int nIndex = m_ComboOutput.AddString(pOutput->GetName());
if (nIndex >= 0)
{
m_ComboOutput.SetItemDataPtr(nIndex, pOutput);
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COP_Output::FillInputList(void)
{
if (!m_pMapEntityList)
{
return;
}
//
// Add all entity inputs to the inputs combo box.
//
m_ComboInput.SetRedraw(FALSE);
m_ComboInput.ResetContent();
// CUtlVector<GDclass*> classCache;
CUtlRBTree<int,int> classCache;
SetDefLessFunc( classCache );
FOR_EACH_OBJ( *m_pMapEntityList, pos )
{
CMapEntity *pEntity = m_pMapEntityList->Element(pos);
Assert(pEntity != NULL);
if (pEntity == NULL)
continue;
//
// Get the entity's class, which contains the list of inputs that this entity exposes.
//
GDclass *pClass = pEntity->GetClass();
if (pClass == NULL)
continue;
// check if class was already added
if ( classCache.Find( (int)pClass ) != -1 )
continue;
classCache.Insert( (int)pClass );
//
// Add this class' inputs to the list.
//
int nCount = pClass->GetInputCount();
for (int i = 0; i < nCount; i++)
{
CClassInput *pInput = pClass->GetInput(i);
bool bAddInput = true;
//
// Don't add the input to the combo box if another input with the same name
// and type is already there.
//
int nIndex = m_ComboInput.FindStringExact(-1, pInput->GetName());
if (nIndex != CB_ERR)
{
CClassInput *pExistingInput = (CClassInput *)m_ComboInput.GetItemDataPtr(nIndex);
if (pExistingInput->GetType() == pInput->GetType())
{
bAddInput = false;
}
}
if (bAddInput)
{
nIndex = m_ComboInput.AddString(pInput->GetName());
if (nIndex >= 0)
{
m_ComboInput.SetItemDataPtr(nIndex, pInput);
}
}
}
}
m_ComboInput.SetRedraw(TRUE);
}
//-----------------------------------------------------------------------------
// Purpose: Fills the list of outputs with outputs common to all the selected entities.
//-----------------------------------------------------------------------------
void COP_Output::FillOutputList(void)
{
if ( m_EntityList.Count() == 0 )
{
return;
}
//
// Determine what the currently selected output is (if any).
//
CClassOutput *pSelectedOutput;
int nOutput = m_ComboOutput.GetCurSel();
if (nOutput != CB_ERR)
{
pSelectedOutput = (CClassOutput *)m_ComboOutput.GetItemDataPtr(nOutput);
}
else
{
pSelectedOutput = NULL;
}
//
// Add the entity outputs to the outputs combo box.
//
m_ComboOutput.SetRedraw(FALSE);
m_ComboOutput.ResetContent();
bool bFirst = true;
FOR_EACH_OBJ( m_EntityList, pos )
{
CMapEntity *pEntity = m_EntityList.Element(pos);
if (bFirst)
{
//
// The first entity adds its outputs to the list.
//
AddEntityOutputs(pEntity);
bFirst = false;
}
else
{
//
// All subsequent entities filter the output list.
//
FilterEntityOutputs(pEntity);
}
}
if (m_ComboOutput.GetCount() == 0)
{
m_ComboOutput.EnableWindow(false);
}
m_ComboOutput.SetRedraw(TRUE);
}
//-----------------------------------------------------------------------------
// Purpose: Fills the list of targets with entities that have "targetname" keys.
//-----------------------------------------------------------------------------
void COP_Output::FillTargetList(void)
{
m_bIgnoreTextChanged = true;
m_ComboTarget.SetEntityList(m_pMapEntityList);
m_bIgnoreTextChanged = false;
}
//-----------------------------------------------------------------------------
// Purpose: Removes all outputs from the outputs combo box that are NOT present
// in the given entity's output list. Used when multiple entities are
// selected into the Entity Properties dialog.
// Input : pEntity - Entity to use for filter.
//-----------------------------------------------------------------------------
void COP_Output::FilterEntityOutputs(CMapEntity *pEntity)
{
//
// Make sure that this entity has a valid class to use for filtering.
//
GDclass *pClass = pEntity->GetClass();
if (pClass == NULL)
{
return;
}
//
// Remove any outputs from the combo box that are not in the class.
//
char szText[MAX_PATH];
int nCount = m_ComboOutput.GetCount();
if (nCount > 0)
{
for (int i = nCount - 1; i >= 0; i--)
{
if (m_ComboOutput.GetLBText(i, szText) != CB_ERR)
{
if (pClass->FindOutput(szText) == NULL)
{
m_ComboOutput.DeleteString(i);
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COP_Output::FilterOutputList(void)
{
// dvs: Possibly unnecessary. For example, if they choose an input, then
// choose an incompatible output, the input will become red to indicate
// the incompatibilty. So maybe the outputs can always contain the set of
// all outputs common to the selected entities.
}
//-----------------------------------------------------------------------------
// Purpose: Filters the list of inputs based on the current selected target.
//-----------------------------------------------------------------------------
void COP_Output::FilterInputList(void)
{
char szTarget[MAX_ENTITY_NAME_LEN];
CMapEntityList *pTargets = GetTarget(szTarget, sizeof(szTarget));
if (pTargets != NULL)
{
//
// Remove all items from the inputs combo that:
//
// 1) Are not compatible with the currently selected output, OR
// 2) Are not found in the currently selected targets list.
//
int nCount = m_ComboInput.GetCount();
if (nCount > 0)
{
for (int i = nCount - 1; i >= 0; i--)
{
CClassInput *pInput = (CClassInput *)m_ComboInput.GetItemDataPtr(i);
if (!MapEntityList_HasInput(pTargets, pInput->GetName(), pInput->GetType()))
{
m_ComboInput.DeleteString(i);
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COP_Output::FilterTargetList(void)
{
#if 0 // Not used...
char szInput[MAX_IO_NAME_LEN];
CClassInput *pInput = GetInput(szInput, sizeof(szInput));
//
// Remove all items from the targets combo that:
//
// 1) Do not have the selected input name OR
// 2) Do not have inputs that are compatible with the selected output.
//
int nCount = m_ComboTarget.GetCount();
if (nCount > 0)
{
for (int i = nCount - 1; i >= 0; i--)
{
CMapEntityList *pTargets = (CMapEntityList *)m_ComboTarget.GetItemDataPtr(i);
if (!MapEntityList_HasInput(pTargets, pInput->GetName(), pInput->GetType()))
{
m_ComboTarget.DeleteString(i);
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Returns the currently selected input, NULL if unknown.
// Input : szInput - Receives the text in the Input combo edit control.
// nSize - Size of buffer pointed to by szInput.
//-----------------------------------------------------------------------------
CClassInput *COP_Output::GetInput(char *szInput, int nSize)
{
szInput[0] = '\0';
int nCurSel = m_ComboInput.GetCurSel();
if (nCurSel == CB_ERR)
{
if (m_ComboInput.GetWindowText(szInput, nSize) > 0)
{
nCurSel = m_ComboInput.FindStringExact(-1, szInput);
}
}
CClassInput *pInput = NULL;
if (nCurSel != CB_ERR)
{
m_ComboInput.GetLBText(nCurSel, szInput);
pInput = (CClassInput *)m_ComboInput.GetItemDataPtr(nCurSel);
}
return(pInput);
}
//-----------------------------------------------------------------------------
// Purpose: Returns the currently selected output, NULL if unknown.
// Input : szOutput - Receives the text in the Output combo edit control.
// nSize - Size of buffer pointed to by szOutput.
//-----------------------------------------------------------------------------
CClassOutput *COP_Output::GetOutput(char *szOutput, int nSize)
{
szOutput[0] = '\0';
int nCurSel = m_ComboOutput.GetCurSel();
if (nCurSel == CB_ERR)
{
if (m_ComboOutput.GetWindowText(szOutput, nSize) > 0)
{
nCurSel = m_ComboOutput.FindStringExact(-1, szOutput);
}
}
CClassOutput *pOutput = NULL;
if (nCurSel != CB_ERR)
{
m_ComboOutput.GetLBText(nCurSel, szOutput);
pOutput = (CClassOutput *)m_ComboOutput.GetItemDataPtr(nCurSel);
}
return(pOutput);
}
//-----------------------------------------------------------------------------
// Purpose: Returns the currently selected target list, NULL if unknown.
// Input : szTarget - Receives the text in the Target combo edit control.
// nSize - Size of buffer pointed to by szTarget.
//-----------------------------------------------------------------------------
CMapEntityList *COP_Output::GetTarget(char *szTarget, int nSize)
{
szTarget[0] = '\0';
CString str = m_ComboTarget.GetCurrentItem();
Q_strncpy( szTarget, str, nSize );
return m_ComboTarget.GetSubEntityList( szTarget );
}
//-----------------------------------------------------------------------------
// Purpose: Called when the contents of the delay edit box change.
//-----------------------------------------------------------------------------
void COP_Output::OnEditDelay(void)
{
UpdateEditedDelays();
}
//-----------------------------------------------------------------------------
// Purpose: Called when the contents of the target combo edit box change.
//-----------------------------------------------------------------------------
void COP_Output::OnFireOnce(void)
{
UpdateEditedFireOnce();
}
//-----------------------------------------------------------------------------
// Purpose: Called when they change the "Show Hidden Targets" checkbox.
//-----------------------------------------------------------------------------
void COP_Output::OnShowHiddenTargetsAsBroken()
{
// Remember the last state of this checkbox.
Options.general.bShowHiddenTargetsAsBroken = (m_ctlShowHiddenTargetsAsBroken.GetCheck() != FALSE);
// Refresh.
int nCount = m_ListCtrl.GetItemCount();
for ( int i=0; i < nCount; i++ )
{
UpdateItemValidity( i );
}
//UpdateConnectionList();
}
//-----------------------------------------------------------------------------
// Purpose: React to the input combo box being changed
//-----------------------------------------------------------------------------
void COP_Output::InputChanged(void)
{
// Updating the listbox data, will trigger the edit
// controls to update. They don't need to be
bSkipEditControlRefresh = true;
char szInput[MAX_IO_NAME_LEN];
CClassInput *pInput = GetInput(szInput, sizeof(szInput));
UpdateCombosForSelectedInput(pInput);
UpdateEditedInputs();
}
//-----------------------------------------------------------------------------
// Purpose: Called when selection of input combo box chages
//-----------------------------------------------------------------------------
void COP_Output::OnSelChangeInput(void)
{
InputChanged();
}
//-----------------------------------------------------------------------------
// Purpose: Called when the contents of the input combo edit box change.
//-----------------------------------------------------------------------------
void COP_Output::OnEditUpdateInput(void)
{
InputChanged();
}
//------------------------------------------------------------------------------
// Purpose: React to the output combo box being changed
//------------------------------------------------------------------------------
void COP_Output::OutputChanged(void)
{
// Updating the listbox data, will trigger the edit
// controls to update. They don't need to be
bSkipEditControlRefresh = true;
char szOutput[MAX_IO_NAME_LEN];
CClassOutput *pOutput = GetOutput(szOutput, sizeof(szOutput));
UpdateCombosForSelectedOutput(pOutput);
UpdateEditedOutputs();
}
//-----------------------------------------------------------------------------
// Purpose: Called when selection of output combo box chages
//-----------------------------------------------------------------------------
void COP_Output::OnSelChangeOutput(void)
{
OutputChanged();
}
//-----------------------------------------------------------------------------
// Purpose: Called when the contents of the output combo edit box change.
//-----------------------------------------------------------------------------
void COP_Output::OnEditUpdateOutput(void)
{
OutputChanged();
}
//-----------------------------------------------------------------------------
// Purpose: Called when selection of parameter combo box chages
//-----------------------------------------------------------------------------
void COP_Output::OnSelChangeParam(void)
{
// If user picked <none> selection (the only valid one) clear window text
CComboBox *pParamEdit = ( CComboBox* )GetDlgItem( IDC_EDIT_CONN_PARAM );
if (pParamEdit->GetCurSel() != CB_ERR)
{
pParamEdit->SetWindowText("");
}
UpdateEditedParams();
}
//-----------------------------------------------------------------------------
// Purpose: Called when the contents of the parameter combo edit box change.
//-----------------------------------------------------------------------------
void COP_Output::OnEditUpdateParam(void)
{
UpdateEditedParams();
}
//-----------------------------------------------------------------------------
// Purpose: Updates the dialog based on the currently selected input.
// Input : pInput - Pointer to the input that is selected, NULL if none or
// ambiguous/unresolved.
//-----------------------------------------------------------------------------
void COP_Output::UpdateCombosForSelectedInput(CClassInput *pInput)
{
// Enable / Disable param box based on input type if allowed
if (!m_bNoParamEdit)
{
CComboBox *pParamCombo = (CComboBox *)GetDlgItem(IDC_EDIT_CONN_PARAM);
bool bEnable = ((!pInput) || (pInput && (pInput->GetType() != iotVoid)));
if (!bEnable)
{
// Save the param so we can restore it if they switch right back.
CString strTemp;
pParamCombo->GetWindowText(strTemp);
if (strTemp.Compare(PARAM_STRING_NONE))
{
m_strLastParam = strTemp;
}
// Switch back to <none> if we're disabling the parameter combo.
pParamCombo->SetCurSel(0);
}
else if (!m_strLastParam.IsEmpty())
{
pParamCombo->SetWindowText(m_strLastParam);
}
UpdateEditedParams();
pParamCombo->EnableWindow(bEnable);
m_bEntityParamTarget = pInput && (pInput->GetType() == iotEHandle);
GetDlgItem(IDC_PICK_ENTITY_PARAM)->EnableWindow( m_bEntityParamTarget );
}
if (pInput != NULL)
{
//
// Known input, render it in black.
//
m_ComboInput.SetTextColor(RGB(0, 0, 0));
}
else
{
//
// Unknown input, render it in red.
//
m_ComboInput.SetTextColor(RGB(255, 0, 0));
}
m_ComboInput.RedrawWindow();
}
//-----------------------------------------------------------------------------
// Purpose: Updates the dialog based on the currently selected output.
// Input : pOutput - Pointer to the output that is selected, NULL if none or
// ambiguous/unresolved.
//-----------------------------------------------------------------------------
void COP_Output::UpdateCombosForSelectedOutput(CClassOutput *pOutput)
{
if (pOutput != NULL)
{
//
// Known output, render it in black.
//
m_ComboOutput.SetTextColor(RGB(0, 0, 0));
}
else
{
//
// Unknown output, render it in red.
//
m_ComboOutput.SetTextColor(RGB(255, 0, 0));
}
m_ComboOutput.RedrawWindow();
}
//-----------------------------------------------------------------------------
// Purpose: Stops entity picking.
//-----------------------------------------------------------------------------
void COP_Output::StopPicking(void)
{
if (m_bPickingEntities)
{
m_bPickingEntities = false;
ToolManager()->SetTool(TOOL_POINTER);
CButton *pButton = (CButton *)GetDlgItem(IDC_PICK_ENTITY);
if (pButton)
{
pButton->SetCheck(0);
}
pButton = (CButton *)GetDlgItem(IDC_PICK_ENTITY_PARAM);
if (pButton)
{
pButton->SetCheck(0);
}
if ( m_ComboTarget.IsWindowEnabled() )
{
GetDlgItem(IDC_PICK_ENTITY)->EnableWindow( true );
}
CComboBox* pParamEdit = ( CComboBox* )GetDlgItem( IDC_EDIT_CONN_PARAM );
if ( pParamEdit->IsWindowEnabled() )
{
GetDlgItem(IDC_PICK_ENTITY_PARAM)->EnableWindow( m_bEntityParamTarget );
}
}
}
void COP_Output::OnSize( UINT nType, int cx, int cy )
{
m_AnchorMgr.OnSize();
}