source-engine/hammer/objectproperties.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "stdafx.h"
#include "hammer.h"
#include "ObjectProperties.h"
#include "ObjectPage.h"
#include "OP_Flags.h"
#include "OP_Groups.h"
#include "OP_Entity.h"
#include "OP_Output.h"
#include "OP_Model.h"
#include "OP_Input.h"
#include "MapDoc.h"
#include "MapView.h"
#include "MapEntity.h"
#include "MapGroup.h"
#include "MapInstance.h"
#include "MapSolid.h"
#include "MapStudioModel.h"
#include "MapWorld.h"
#include "History.h"
#include "GlobalFunctions.h"
#include "Selection.h"
#include "CustomMessages.h"
#include "Camera.h"
#include "Manifest.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

//
// Layout types for remembering the last layout of the dialog. We could
// also remember this as an array of booleans for which pages were visible.
//
enum LayoutType_t
{
	ltZero,			// Special enums for initialization
	ltNone,

	ltSolid,		// Enable groups only
	ltSolidMulti,	// Enable none
	ltEntity,		// Enable entity, flags, groups
	ltEntityMulti,	// Enable entity, flags
	ltWorld,		// Enable entity, flags, groups
	ltModelEntity,	// Enable entity, flags, groups, model, 
	ltMulti			// Enable none
};



IMPLEMENT_DYNAMIC(CObjectProperties, CPropertySheet)


BEGIN_MESSAGE_MAP(CObjectProperties, CPropertySheet)
	//{{AFX_MSG_MAP(CObjectProperties)
	ON_WM_KILLFOCUS()
	ON_WM_ACTIVATE()
	ON_WM_CLOSE()
	ON_WM_PAINT()
	ON_WM_SIZE()
	ON_WM_SHOWWINDOW()
	ON_WM_CREATE()
	ON_COMMAND(IDOK, OnApply )
	ON_COMMAND(ID_APPLY_NOW, OnApply )
	ON_COMMAND(IDCANCEL, OnCancel)
	ON_COMMAND(IDI_INPUT, OnInputs)
	ON_COMMAND(IDI_OUTPUT, OnOutputs)
	ON_COMMAND(IDD_EDIT_INSTANCE, OnEditInstance)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

IMPLEMENT_DYNAMIC(editCMapClass, CObject);
IMPLEMENT_DYNAMIC(editCEditGameClass, CObject);


static editCMapClass e_CMapClass;
static editCEditGameClass e_CEditGameClass;


//-----------------------------------------------------------------------------
// Purpose: Constructor.
//-----------------------------------------------------------------------------
CObjectProperties::CObjectProperties(void) :
	CPropertySheet()
{
	m_bDummy = false;
	m_pDummy = NULL;
	m_pInputButton = NULL;
	m_pOutputButton = NULL;
	m_pInstanceButton = NULL;
	m_pOrgObjects = NULL;
	m_bDataDirty = false;
	m_bCanEdit = false;

	CreatePages();
}


//-----------------------------------------------------------------------------
// Purpose: Constructor.
// Input  : nIDCaption - 
//			pParentWnd - 
//			iSelectPage - 
//-----------------------------------------------------------------------------
CObjectProperties::CObjectProperties(UINT nIDCaption, CWnd* pParentWnd, UINT iSelectPage)
	:CPropertySheet(nIDCaption, pParentWnd, iSelectPage)
{
	m_bDummy = false;
	m_pDummy = NULL;
	m_pInputButton = NULL;
	m_pOutputButton = NULL;
	m_pInstanceButton = NULL;
	m_bCanEdit = false;

	CreatePages();
}


//-----------------------------------------------------------------------------
// Purpose: Constructor.
// Input  : pszCaption - 
//			pParentWnd - 
//			iSelectPage - 
//-----------------------------------------------------------------------------
CObjectProperties::CObjectProperties(LPCTSTR pszCaption, CWnd* pParentWnd, UINT iSelectPage)
	:CPropertySheet(pszCaption, pParentWnd, iSelectPage)
{
	m_bDummy = false;
	m_pDummy = NULL;
	m_pInputButton = NULL;
	m_pOutputButton = NULL;
	m_pInstanceButton = NULL;
	m_bCanEdit = false;

	CreatePages();
}


//-----------------------------------------------------------------------------
// Purpose: Destructor.
//-----------------------------------------------------------------------------
CObjectProperties::~CObjectProperties()
{
	delete m_pDummy;

	delete m_pEntity;
	delete m_pFlags;
	delete m_pGroups;
	delete m_pOutput;
	delete m_pInput;
	delete m_pModel;

	delete m_pInputButton;
	delete m_pOutputButton;
	delete m_pInstanceButton;

	delete[] m_ppPages;
}


//-----------------------------------------------------------------------------
// Purpose: Creates all possible pages and attaches our object list to them.
//			Not all will be used depending on the types of objects being edited.
//-----------------------------------------------------------------------------
void CObjectProperties::CreatePages(void)
{
	//VPROF_BUDGET( "CObjectProperties::CreatePages", "Object Properties" );

	m_pEntity = new COP_Entity;
	m_pEntity->SetObjectList(&m_DstObjects);

	m_pFlags = new COP_Flags;
	m_pFlags->SetObjectList(&m_DstObjects);

	// There are some dependencies between the entity and flags tabs since
	// they both edit the spawnflags property.
	m_pEntity->SetFlagsPage( m_pFlags );
	m_pFlags->SetEntityPage( m_pEntity );

	m_pGroups = new COP_Groups;
	m_pGroups->SetObjectList(&m_DstObjects);

	m_pOutput = new COP_Output;
	m_pOutput->SetObjectList(&m_DstObjects);

	m_pInput = new COP_Input;
	m_pInput->SetObjectList(&m_DstObjects);

	m_pModel = new COP_Model;
	m_pModel->SetObjectList(&m_DstObjects);

	m_pDummy = new CPropertyPage(IDD_OBJPAGE_DUMMY);

	m_ppPages = NULL;
	m_nPages = 0;

	m_pLastActivePage = NULL;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pType - 
//-----------------------------------------------------------------------------
PVOID CObjectProperties::GetEditObject(CRuntimeClass *pType)
{
	//VPROF_BUDGET( "CObjectProperties::GetEditObject", "Object Properties" );

	if (pType == RUNTIME_CLASS(editCMapClass))
	{
		return PVOID((CMapClass*)&e_CMapClass);
	}
	else if (pType == RUNTIME_CLASS(editCEditGameClass))
	{
		return PVOID((CEditGameClass*)&e_CEditGameClass);
	}

	Assert(0);
	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pobj - 
//			pType - 
//-----------------------------------------------------------------------------
PVOID CObjectProperties::GetEditObjectFromMapObject(CMapClass *pobj, CRuntimeClass *pType)
{
	//VPROF_BUDGET( "CObjectProperties::GetEditObjectFromMapObject", "Object Properties" );

	if (pType == RUNTIME_CLASS(editCMapClass))
	{
		return PVOID(pobj);
	}
	else if (pType == RUNTIME_CLASS(editCEditGameClass))
	{
		if (pobj->IsMapClass(MAPCLASS_TYPE(CMapEntity)))
		{
			return PVOID((CEditGameClass*)((CMapEntity*)pobj));
		}

		if (pobj->IsMapClass(MAPCLASS_TYPE(CMapWorld)))
		{
			return PVOID((CEditGameClass*)((CMapWorld*)pobj));
		}
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pobj - 
//-----------------------------------------------------------------------------
void CObjectProperties::CopyDataToEditObjects(CMapClass *pobj)
{
	//VPROF_BUDGET( "CObjectProperties::CopyDataToEditObjects", "Object Properties" );

	//
	// All copies here are done without updating object dependencies, because
	// we're copying to a place that is outside of the world.
	//
	e_CMapClass.CopyFrom(pobj, false);

	if (pobj->IsMapClass(MAPCLASS_TYPE(CMapEntity)))
	{
		e_CEditGameClass.CopyFrom((CEditGameClass *)((CMapEntity *)pobj));
	}
	else if (pobj->IsMapClass(MAPCLASS_TYPE(CMapWorld)))
	{
		e_CEditGameClass.CopyFrom((CEditGameClass *)((CMapWorld *)pobj));
	}
}

//------------------------------------------------------------------------------
// Purpose:
// Input  : nState - 
//------------------------------------------------------------------------------
void CObjectProperties::SetOutputButtonState(int nState)
{
	//VPROF_BUDGET( "CObjectProperties::SetOutputButtonState", "Object Properties" );

	if (nState == CONNECTION_GOOD)
	{
		m_pOutputButton->SetIcon(m_hIconOutputGood);
		m_pOutputButton->ShowWindow(SW_SHOW);
		m_pOutputButton->Invalidate();
		m_pOutputButton->UpdateWindow();
	}
	else if (nState == CONNECTION_BAD)
	{
		m_pOutputButton->SetIcon(m_hIconOutputBad);
		m_pOutputButton->ShowWindow(SW_SHOW);
		m_pOutputButton->Invalidate();
		m_pOutputButton->UpdateWindow();
	}
	else
	{
		m_pOutputButton->ShowWindow(SW_HIDE);
		m_pOutputButton->Invalidate();
		m_pOutputButton->UpdateWindow();
	}
}


//------------------------------------------------------------------------------
// Purpose:
// Input  : nState - 
//------------------------------------------------------------------------------
void CObjectProperties::SetInputButtonState(int nState)
{
	//VPROF_BUDGET( "CObjectProperties::SetInputButtonState", "Object Properties" );

	if (nState == CONNECTION_GOOD)
	{
		m_pInputButton->SetIcon(m_hIconInputGood);
		m_pInputButton->ShowWindow(SW_SHOW);
		m_pInputButton->Invalidate();
		m_pInputButton->UpdateWindow();
	}
	else if (nState == CONNECTION_BAD)
	{
		m_pInputButton->SetIcon(m_hIconInputBad);
		m_pInputButton->ShowWindow(SW_SHOW);
		m_pInputButton->Invalidate();
		m_pInputButton->UpdateWindow();
	}
	else
	{
		m_pInputButton->ShowWindow(SW_HIDE);
		m_pInputButton->Invalidate();
		m_pInputButton->UpdateWindow();
	}
}


//------------------------------------------------------------------------------
// Purpose: Set icon being displayed on output button.
//------------------------------------------------------------------------------
void CObjectProperties::UpdateOutputButton(void)
{
	//VPROF_BUDGET( "CObjectProperties::UpdateOutputButton", "Object Properties" );

	if (!m_pOutputButton)
	{
		return;
	}

	bool bHaveConnection = false;
	bool bIgnoreHiddenTargets = false;
	if ( m_pOutput )
		bIgnoreHiddenTargets = !m_pOutput->ShouldShowHiddenTargets();

	FOR_EACH_OBJ( m_DstObjects, pos )
	{
		CMapClass *pObject = m_DstObjects.Element(pos);

		if ((pObject != NULL) && (pObject->IsMapClass(MAPCLASS_TYPE(CMapEntity))))
		{
			CMapEntity *pEntity = (CMapEntity *)pObject;
			int nStatus = CEntityConnection::ValidateOutputConnections(pEntity, true, bIgnoreHiddenTargets);
			if (nStatus == CONNECTION_BAD)
			{
				SetOutputButtonState(CONNECTION_BAD);
				return;
			}
			else if (nStatus == CONNECTION_GOOD)
			{
				bHaveConnection = true;
			}
		}
	}
	if (bHaveConnection)
	{
		SetOutputButtonState(CONNECTION_GOOD);
	}
	else
	{
		SetOutputButtonState(CONNECTION_NONE);
	}
}


//------------------------------------------------------------------------------
// Purpose: Set icon being displayed on input button.
//------------------------------------------------------------------------------
void CObjectProperties::UpdateInputButton()
{
	//VPROF_BUDGET( "CObjectProperties::UpdateInputButton", "Object Properties" );

	if (!m_pInputButton)
	{
		return;
	}

	bool bHaveConnection = false;

	FOR_EACH_OBJ( m_DstObjects, pos )
	{
		CMapClass *pObject = m_DstObjects.Element(pos);

		if ((pObject != NULL) && (pObject->IsMapClass(MAPCLASS_TYPE(CMapEntity))))
		{
			CMapEntity *pEntity = (CMapEntity *)pObject;
			int nStatus = CEntityConnection::ValidateInputConnections(pEntity, false);
			if (nStatus == CONNECTION_BAD)
			{
				SetInputButtonState(CONNECTION_BAD);
				return;
			}
			else if (nStatus == CONNECTION_GOOD)
			{
				bHaveConnection = true;
			}
		}
	}
	if (bHaveConnection)
	{
		SetInputButtonState(CONNECTION_GOOD);
	}
	else
	{
		SetInputButtonState(CONNECTION_NONE);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Finds/Creates the buttons.
//-----------------------------------------------------------------------------
void CObjectProperties::CreateButtons(void)
{
	//VPROF_BUDGET( "CObjectProperties::CreateButtons", "Object Properties" );

#if 0
	// Get the screen location of the hidden apply button(ID_APPLY_NOW)
	rect	rcButton;
	pApplyButton->GetWindowRect( &rcButton );

	// Grab, enable and rename the OK button to be Apply 
	// (Because <enter> only accelerates IDOK)
	// and we dont want "OK" (apply+close) functionality
	CButton	*pOKButton = reinterpret_cast<CButton *>(GetDlgItem(IDOK)); 
	pOKButton->SetWindowTextA("Apply");
	pOKButton->EnableWindow();
	pOKButton->ShowWindow(SW_SHOWNA);
	pOKButton->MoveWindow(&rcButton);
#else
	// Grab, enable and DONT show the OK button
	// (Because <enter> only accelerates IDOK)
	// and we dont want "OK" (apply+close) functionality
	CButton	*pOKButton = reinterpret_cast<CButton *>(GetDlgItem(IDOK)); 
	pOKButton->EnableWindow();
	// Dont show the window, just make it active to forward <enter> -> IDOK -> OnApply

	// Grab and enable & show the hidden Apply button too
	CButton *pApplyButton = reinterpret_cast<CButton *>(GetDlgItem(ID_APPLY_NOW));
	pApplyButton->SetButtonStyle( pApplyButton->GetButtonStyle() | BS_DEFPUSHBUTTON );
	pApplyButton->EnableWindow();
	pApplyButton->ShowWindow(SW_SHOWNA);
#endif
	// Grab and enable & show the hidden Cancel button too
	CButton *pCancelButton = reinterpret_cast<CButton *>(GetDlgItem(IDCANCEL));
	pCancelButton->EnableWindow();
	pCancelButton->ShowWindow(SW_SHOWNA);

	//
	// Load Icons
	//
	CWinApp *pApp = AfxGetApp();
	m_hIconOutputGood = pApp->LoadIcon(IDI_OUTPUT);
	m_hIconOutputBad  = pApp->LoadIcon(IDI_OUTPUTBAD);
	m_hIconInputGood  = pApp->LoadIcon(IDI_INPUT);
	m_hIconInputBad   = pApp->LoadIcon(IDI_INPUTBAD);

	// Create buttons to display connection status icons
	CRect rect;
	GetWindowRect(&rect);
	rect.InflateRect(0, 0, 0, 32);
	MoveWindow(&rect, FALSE);
	GetClientRect(&rect);

	m_pInputButton = new CButton;
	m_pInputButton->Create(_T("My button"), WS_CHILD|WS_VISIBLE|BS_ICON|BS_FLAT, CRect(6,rect.bottom - 34,38,rect.bottom - 2), this, IDI_INPUT);

	m_pOutputButton = new CButton;
	m_pOutputButton->Create(_T("My button"), WS_CHILD|WS_VISIBLE|BS_ICON|BS_FLAT, CRect(40,rect.bottom - 34,72,rect.bottom - 2), this, IDI_OUTPUT);

	m_pInstanceButton = new CButton;
	m_pInstanceButton->Create( _T( "Edit Instance" ), WS_CHILD|WS_VISIBLE|BS_TEXT, CRect( 6, rect.bottom - 28, 140, rect.bottom - 4 ), this, IDD_EDIT_INSTANCE );
}


//-----------------------------------------------------------------------------
// Purpose: Returns the appropriate page layout for the current object list.
//-----------------------------------------------------------------------------
void CObjectProperties::GetTabsForLayout(LayoutType_t eLayoutType, bool &bEntity, bool &bGroups, bool &bFlags, bool &bModel)
{
	//VPROF_BUDGET( "CObjectProperties::GetTabsForLayout", "Object Properties" );

	bEntity = bGroups = bFlags = bModel = false;

	switch (eLayoutType)
	{
		case ltEntity:
		case ltEntityMulti:
		case ltModelEntity:
		{
			bFlags = true;
			bEntity = true;
			bGroups = true;
			bModel = (eLayoutType == ltModelEntity);
			break;
		}

		case ltSolid:
		{
			bGroups = true;
			break;
		}

		case ltWorld:
		{
			bEntity = true;
			break;
		}

		case ltMulti:
		case ltSolidMulti:
		{
			bGroups = true;
			break;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Returns the appropriate page layout for the current object list.
//-----------------------------------------------------------------------------
LayoutType_t CObjectProperties::GetLayout(void)
{
	//VPROF_BUDGET( "CObjectProperties::GetLayout", "Object Properties" );

	LayoutType_t eLayoutType = ltNone;

	if ((m_DstObjects.Count() == 0) || (CMapDoc::GetActiveMapDoc() == NULL))
	{
		eLayoutType = ltNone;
	}
	else
	{
		//
		// Figure out which layout to use based on the objects being edited.
		//
		bool bFirst = true;
		MAPCLASSTYPE PrevType = MAPCLASS_TYPE(CMapEntity);
		
		FOR_EACH_OBJ( m_DstObjects, pos )
		{
			CMapClass *pObject = m_DstObjects.Element(pos);
			MAPCLASSTYPE ThisType = pObject->GetType();
			
			if (bFirst)
			{
				bFirst = false;

				if (ThisType == MAPCLASS_TYPE(CMapEntity))
				{
					CMapEntity *pEntity = (CMapEntity *)pObject;

					//
					// Only show the model tab when we have a single entity selected that
					// has a model helper.
					//
					if (m_DstObjects.Count() == 1)
					{
						if (pEntity->GetChildOfType((CMapStudioModel *)NULL))
						{
							eLayoutType = ltModelEntity;
						}
						else
						{
							eLayoutType = ltEntity;
						}
					}
					else
					{
						eLayoutType = ltEntityMulti;
					}
				}
				else if ((ThisType == MAPCLASS_TYPE(CMapSolid)) ||
						(ThisType == MAPCLASS_TYPE(CMapGroup)))
				{
					eLayoutType = (m_DstObjects.Count() == 1) ? ltSolid : ltSolidMulti;
				}
				else if (ThisType == MAPCLASS_TYPE(CMapWorld))
				{
					eLayoutType = ltWorld;
				}
			}
			else if (ThisType != PrevType)
			{
				eLayoutType = ltMulti;
			}

			PrevType = ThisType;
		}
	}

	return eLayoutType;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectProperties::RestoreActivePage(void)
{
	//VPROF_BUDGET( "CObjectProperties::RestoreActivePage", "Object Properties" );

	//
	// Try to restore the previously active page. If it is not in the page list
	// just activate page zero.
	//
	bool bPageSet = false;
	for (int i = 0; i < m_nPages; i++)
	{
		if (m_ppPages[i] == m_pLastActivePage)
		{
			SetActivePage(m_pLastActivePage);
			bPageSet = true;
			break;
		}
	}

	if (!bPageSet)
	{
		SetActivePage(0);
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectProperties::SaveActivePage(void)
{
	//VPROF_BUDGET( "CObjectProperties::SaveActivePage", "Object Properties" );

	CObjectPage *pPage = (CObjectPage *)GetActivePage();
	if (pPage != NULL)
	{
		m_pLastActivePage = pPage;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets up pages to display based on "m_DstObjects".
// Output : Returns TRUE if the page structure changed, FALSE if not.
//-----------------------------------------------------------------------------
BOOL CObjectProperties::SetupPages(void)
{
	//VPROF_BUDGET( "CObjectProperties::SetupPages", "Object Properties" );

	static bool bFirstTime = true;
	static LayoutType_t eLastLayoutType = ltZero;
	static LayoutType_t eLastValidLayoutType = ltZero;

	//
	// Save the current active page.
	//
	if ((eLastLayoutType != ltZero) && (eLastLayoutType != ltNone))
	{	
		SaveActivePage();
	}

	//
	// Determine the appropriate layout for the current object list.
	//	
	LayoutType_t eLayoutType = GetLayout();

	bool bEntity;
	bool bGroups;
	bool bFlags;
	bool bModel;
	GetTabsForLayout(eLayoutType, bEntity, bGroups, bFlags, bModel);

	//
	// If the layout has not changed, we're done. All the pages are already set up.
	//
	if (eLayoutType == eLastLayoutType)
	{
		//
		// Try to restore the previously active page. If it has been deleted just
		// activate page zero.
		//
		RestoreActivePage();
		return(FALSE);
	}

	//
	// Forget the last active page when the layout changes from one
	// valid layout to another (such as from entity to solid).
	// Don't reset when switching between model entities and non-model entities,
	// because it's annoying to be switched away from the Outputs tab.
	//
	if ((eLayoutType != ltNone) && (eLayoutType != eLastValidLayoutType) &&
		!((eLayoutType == ltEntity) && (eLastValidLayoutType == ltModelEntity)) &&
		!((eLayoutType == ltModelEntity) && (eLastValidLayoutType == ltEntity)))
	{
		m_pLastActivePage = NULL;
		eLastValidLayoutType = eLayoutType;
	}

	eLastLayoutType = eLayoutType;

	CObjectPage::s_bRESTRUCTURING = TRUE;

	UINT nAddPages = bEntity + bGroups + bFlags + bModel;

	// don't want to change focus .. just pages!
	CWnd *pActiveWnd = GetActiveWindow();

	bool bDisabledraw = false;
	if (::IsWindow(m_hWnd) && IsWindowVisible())
	{
		SetRedraw(FALSE);
		bDisabledraw = true;
	}

	if (!m_bDummy && (nAddPages == 0))
	{
		AddPage(m_pDummy);
		m_bDummy = true;
	}
	else if (m_bDummy && (nAddPages > 0))
	{
		RemovePage(m_pDummy);
		m_bDummy = false;
	}

	struct
	{
		bool m_bIsVisible;
		bool m_bWantVisible;
		CObjectPage *m_pPage;
	} pages[] =
	{
		{false, bEntity, m_pEntity},
		{false, bEntity, m_pOutput},
		{false, bEntity, m_pInput},
		{false, bModel, m_pModel},
		{false, bFlags, m_pFlags},
		{false, bGroups, m_pGroups}
	};

	// First, remove pages that we don't want visible.
	// Also store if they're visible.
	for ( int i=0; i < ARRAYSIZE( pages ); i++ )
	{
		pages[i].m_bIsVisible = ( GetPageIndex( pages[i].m_pPage ) != -1 );
		if ( pages[i].m_bIsVisible && !pages[i].m_bWantVisible)
		{
			// It's visible but they don't want it there.
			RemovePage( pages[i].m_pPage );
			pages[i].m_bIsVisible = false;
		}
	}
	
	// We're about to add pages, but it'll only add them to the right of what's already there, 
	// so we must get rid of anything to the right of our leftmost addition.
	for ( int i=0; i < ARRAYSIZE( pages ); i++ )
	{
		if ( !pages[i].m_bIsVisible && pages[i].m_bWantVisible )
		{
			// Ok, page i needs to be on, so nuke everything to the right of it.
			for ( int j=i+1; j < ARRAYSIZE( pages ); j++ )
			{
				if ( pages[j].m_bIsVisible )
				{
					RemovePage( pages[j].m_pPage );
					pages[j].m_bIsVisible = false;
				}
			}
			break;
		}
	}
	
	for ( int i=0; i < ARRAYSIZE( pages ); i++ )
	{
		if ( !pages[i].m_bIsVisible && pages[i].m_bWantVisible )
			AddPage( pages[i].m_pPage );
	}

	//
	// Store active pages in our array.
	//
	if (!m_bDummy)
	{
		delete[] m_ppPages;
		m_nPages = GetPageCount();
		m_ppPages = new CObjectPage*[m_nPages];

		for (int i = 0; i < m_nPages; i++)
		{
			m_ppPages[i] = (CObjectPage *)GetPage(i);
			m_ppPages[i]->m_bFirstTimeActive = true;
			m_ppPages[i]->m_bHasUpdatedData = false;
		}
	}

	CObjectPage::s_bRESTRUCTURING = FALSE;

	//VPROF_BUDGET( "CObjectProperties::RestoreActivePage", "Object Properties" );
	RestoreActivePage();

	//
	// Enable redraws if they were disabled above.
	//
	if (bDisabledraw)
	{
		SetRedraw(TRUE);
		Invalidate(FALSE);
	}

	// Set button status
	UpdateOutputButton();
	UpdateInputButton();

	if (pActiveWnd != NULL)
	{
		pActiveWnd->SetActiveWindow();
	}

	bFirstTime = false;	

	return TRUE;	// pages changed - return true
}


//------------------------------------------------------------------------------
// Purpose: Set object properties dialogue to the Output tab and highlight
//			the given item
// Input  : pConnection - 
//------------------------------------------------------------------------------
void CObjectProperties::SetPageToOutput(CEntityConnection *pConnection)
{
	if ( m_bDataDirty )
		ReloadData();

	SetActivePage(m_pOutput);
	m_pOutput->SetSelectedConnection(pConnection);
}

void CObjectProperties::SetPageToInput(CEntityConnection *pConnection)
{
	if ( m_bDataDirty )
		ReloadData();

	SetActivePage(m_pInput);
	
	m_pInput->SetSelectedConnection(pConnection);
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectProperties::SaveData(void)
{
	//VPROF_BUDGET( "CObjectProperties::SaveData", "Object Properties" );

	//
	// Make sure window is visible - don't want to save otherwise.
	//
	if (!IsWindowVisible())
	{
		return;
	}

	// we should never save in a dirty state
	if ( m_bDataDirty )
		return;

	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if (!pDoc || !m_DstObjects.Count() || m_bDummy)
	{
		return;
	}

	//
	// Transfer all page data to the objects being edited.
	//
	GetHistory()->MarkUndoPosition( pDoc->GetSelection()->GetList(), "Change Properties");

	// Don't keep all the world's children when we're editing the world, because
	// that's really slow (and pointless since all we're changing is keyvalues).
	bool bKeptWorld = false;
	if (m_DstObjects.Count() == 1)
	{
		CMapClass *pObject = m_DstObjects.Element( 0 );
		if ( IsWorldObject(pObject) )
		{
			GetHistory()->KeepNoChildren(pObject);
			bKeptWorld = true;
		}
	}

	if (!bKeptWorld)
	{
		GetHistory()->Keep(&m_DstObjects);
	}

	for (int i = 0; i < m_nPages; i++)
	{
		//
		// Pages that have never been shown have no hwnd.
		//
		if (IsWindow(m_ppPages[i]->m_hWnd) && m_ppPages[i]->m_bHasUpdatedData )
		{
			m_ppPages[i]->SaveData();
		}
	}

	// Objects may have changed. Update the views.
		
	pDoc->SetModifiedFlag();
}


//-----------------------------------------------------------------------------
// Purpose: Submits the objects to be edited to the property pages so they can
//			update their controls.
// Input  : iPage - Page index or -1 to update all pages.
//-----------------------------------------------------------------------------
void CObjectProperties::LoadDataForPages(int iPage)
{
	//VPROF_BUDGET( "CObjectProperties::LoadDataForPages", "Object Properties" );
	
	if (m_bDummy)
	{
		return;
	}

	//
	// Determine whether we are editing multiple objects or not.
	//
	bool bMultiEdit = (m_DstObjects.Count() > 1);
	m_bCanEdit = true;

	//
	// Submit the edit objects to each page one at a time.
	//
	int nMode = CObjectPage::LoadFirstData;
	
	FOR_EACH_OBJ( m_DstObjects, pos )
	{
		CMapClass *pobj = m_DstObjects.Element(pos);

		if ( pobj->IsEditable() == false )
		{
			m_bCanEdit = false;
		}

		if (iPage != -1)
		{
			//
			// Specific page.
			//
			m_ppPages[iPage]->SetMultiEdit(bMultiEdit);

			void *pObject = GetEditObjectFromMapObject(pobj, m_ppPages[iPage]->GetEditObjectRuntimeClass());
			if (pObject != NULL)
			{
				m_ppPages[iPage]->UpdateData(nMode, pObject, m_bCanEdit);
				m_ppPages[iPage]->m_bHasUpdatedData = true;
			}
		}
		else for (int i = 0; i < m_nPages; i++)
		{
			//
			// All pages.
			//
			m_ppPages[i]->SetMultiEdit(bMultiEdit);

			// This page hasn't even been shown yet. Don't bother updating its data.
			if (m_ppPages[i]->m_bFirstTimeActive)
				continue;

			void *pObject = GetEditObjectFromMapObject(pobj, m_ppPages[i]->GetEditObjectRuntimeClass());
			if (pObject != NULL)
			{
				m_ppPages[i]->UpdateData(nMode, pObject, m_bCanEdit);
				m_ppPages[i]->m_bHasUpdatedData = true;
			}								  
		}

		nMode = CObjectPage::LoadData;
	}

	CButton *pApplyButton = reinterpret_cast<CButton *>(GetDlgItem(ID_APPLY_NOW));
	pApplyButton->EnableWindow( ( m_bCanEdit ? TRUE : FALSE ) );

	//
	// Tell the pages that we are done submitting data.
	//
	if (iPage != -1)
	{
		//
		// Specific page.
		//
		m_ppPages[iPage]->UpdateData(CObjectPage::LoadFinished, NULL, m_bCanEdit);
	}
	else for (int i = 0; i < m_nPages; i++)
	{
		//
		// All pages.
		//

		// This page hasn't even been shown yet. Don't bother updating its data.
		if (m_ppPages[i]->m_bFirstTimeActive)
			continue;

		m_ppPages[i]->UpdateData(CObjectPage::LoadFinished, NULL, m_bCanEdit);
	}

	//
	// Update the input/output icons based on the new data.
	//
	UpdateOutputButton();
	UpdateInputButton();
}


//-----------------------------------------------------------------------------
// Purpose: Adds the object to m_DstObjects unless it is a group, in which case
//			it is expanded (recursively) to its children.
//-----------------------------------------------------------------------------
void CObjectProperties::AddObjectExpandGroups(CMapClass *pObject)
{
	//VPROF_BUDGET( "CObjectProperties::AddObjectExpandGroups", "Object Properties" );

	if (pObject->IsGroup())
	{
		const CMapObjectList *pChildren = pObject->GetChildren();
		
		FOR_EACH_OBJ( *pChildren, pos )
		{
			AddObjectExpandGroups( pChildren->Element(pos) );
		}
	}
	else
	{
		m_DstObjects.AddToTail(pObject);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Updates the property page data when the selection contents change.
// Input  : pObjects - List of currently selected objects.
//-----------------------------------------------------------------------------
void CObjectProperties::ReloadData()
{
	//VPROF_BUDGET( "CObjectProperties::LoadData", "Object Properties" );

	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();

	//
	// Disable window so it does not gain focus during this operation.
	//
	EnableWindow(FALSE);


	//
	// Transfer the objects from pObjects to m_DstObjects, expanding
	// groups to their member children.
	//
	m_DstObjects.RemoveAll();
	if ( m_pOrgObjects )
	{
		FOR_EACH_OBJ( (*m_pOrgObjects), pos )
		{
			AddObjectExpandGroups( m_pOrgObjects->Element(pos) );
		}
	}

	m_pInstanceButton->ShowWindow( SW_HIDE );

	//
	// If there is only one object selected, copy its data to our temporary
	// edit objects.
	//
	if (m_DstObjects.Count() == 1)
	{
		//
		// Copy the single destination object's data to our temporary
		// edit objects.
		//
		CMapClass *pobj = m_DstObjects.Element(0);
		CopyDataToEditObjects( pobj );

		//
		// Set the window title to include the object's description.
		//
		char szTitle[MAX_PATH];
		sprintf(szTitle, "Object Properties: %s", pobj->GetDescription());
		SetWindowText(szTitle);

		CManifestInstance	*pManifestInstance = dynamic_cast< CManifestInstance * >( pobj );
		if ( pManifestInstance )
		{
			CManifest *pManifest = CMapDoc::GetManifest();

			if ( pManifest )
			{
				ShowWindow( SW_HIDE );
				if ( pDoc )
				{
					pDoc->UpdateAllViews( MAPVIEW_UPDATE_SELECTION | MAPVIEW_UPDATE_TOOL | MAPVIEW_RENDER_NOW );
				}
				pManifest->SetPrimaryMap( pManifestInstance->GetManifestMap() );
				return;
			}
		}

		CMapEntity	*pEntity = dynamic_cast< CMapEntity * >( pobj );
		if ( pEntity )
		{
			if ( strcmpi( pEntity->GetClassName(), "func_instance" ) == 0 )
			{
				pDoc->PopulateInstance( pEntity );
				CMapInstance	*pMapInstance = pEntity->GetChildOfType( ( CMapInstance * )NULL );
				if ( pMapInstance && pMapInstance->GetInstancedMap() )
				{
					m_pInstanceButton->ShowWindow( SW_SHOW );
				}
			}
			else if ( strcmpi( pEntity->GetClassName(), "func_instance_parms" ) == 0 )
			{
				if ( pDoc )
				{
					pDoc->PopulateInstanceParms( pEntity );
				}
			}
		}

	}
	else if (m_DstObjects.Count() > 1)
	{
		SetWindowText("Object Properties: multiple objects");
	}
	else
	{
		SetWindowText("Object Properties");
	}

	SetupPages();
	LoadDataForPages();

	EnableWindow(TRUE);

	m_bDataDirty = false;
}


BOOL CObjectProperties::OnInitDialog() 
{
	BOOL b = CPropertySheet::OnInitDialog();
	SetWindowText("Object Properties");

	CreateButtons();
	UpdateAnchors( NULL );
		
	return b;
}


void CObjectProperties::UpdateAnchors( CWnd *pPage )
{
	if ( !GetSafeHwnd() )
		return;
		
	// Anchor stuff.
	HWND hTab = NULL;
	if ( GetTabControl() )
		hTab = GetTabControl()->GetSafeHwnd();

	CAnchorDef anchorDefs[] =
	{
		CAnchorDef( IDOK, k_eSimpleAnchorBottomRight ),
		CAnchorDef( ID_APPLY_NOW, k_eSimpleAnchorBottomRight ),
		CAnchorDef( IDCANCEL, k_eSimpleAnchorBottomRight ),
		CAnchorDef( IDI_INPUT, k_eSimpleAnchorBottomRight ),
		CAnchorDef( IDI_OUTPUT, k_eSimpleAnchorBottomRight ),
		CAnchorDef( IDD_EDIT_INSTANCE, k_eSimpleAnchorBottomRight ),
		CAnchorDef( hTab, k_eSimpleAnchorAllSides ),
		CAnchorDef( pPage ? pPage->GetSafeHwnd() : (HWND)NULL, k_eSimpleAnchorAllSides )
	};
	m_AnchorMgr.Init( GetSafeHwnd(), anchorDefs, ARRAYSIZE( anchorDefs ) );
}


//-----------------------------------------------------------------------------
// Purpose: Closes the object properties dialog, saving changes.
//-----------------------------------------------------------------------------
void CObjectProperties::OnClose(void)
{
	//VPROF_BUDGET( "CObjectProperties::OnClose", "Object Properties" );
	OnApply();

	ShowWindow(SW_HIDE);
}

void CObjectProperties::OnPaint()
{
	CPaintDC dc(this); // device context for painting

	if ( m_bDataDirty )
		ReloadData(); 
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : bShow - 
//			nStatus - 
//-----------------------------------------------------------------------------
void CObjectProperties::OnShowWindow(BOOL bShow, UINT nStatus) 
{
	//VPROF_BUDGET( "CObjectProperties::OnShowWindow", "Object Properties" );

	// Forget the last active page when the window is hidden or shown.
	// FIXME: SetupPages calls SaveActivePage, so we must switch to page 0 here
	SetActivePage(0);
	m_pLastActivePage = NULL;

	CPropertySheet::OnShowWindow(bShow, nStatus);

	for (int i = 0; i < m_nPages; i++)
	{
		m_ppPages[i]->OnShowPropertySheet(bShow, nStatus);
	}
}


void CObjectProperties::OnSize( UINT nType, int cx, int cy )
{
	m_AnchorMgr.OnSize();
}


//-----------------------------------------------------------------------------
// Purpose: Handles the Apply button.
//-----------------------------------------------------------------------------
void CObjectProperties::OnApply(void)
{
	//VPROF_BUDGET( "CObjectProperties::OnApply", "Object Properties" );

	if ( !m_bCanEdit )
	{
		return;
	}

	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !pDoc )
		return;

	//We lock visgroup updates here because activities in the object properties dialog can 
	//change visgroups which, if updated, will change the object properties, causing problems.
	//All visgroup updates will occur at the end of this apply operation.
    bool bLocked = pDoc->VisGroups_LockUpdates( true );

	for (int i = 0; i < m_nPages; i++)
	{
		if (!m_ppPages[i]->OnApply())
		{
			return;
		}
	}

	//
	// Save and reload the data so the GUI updates.
	//
	SaveData();

	ReloadData();
	
	// Pass along the apply message to the entities.
	FOR_EACH_OBJ( m_DstObjects, pos )
	{
		CMapClass *pObject = m_DstObjects.Element( pos );
		if ( pObject )
		{
			pObject->OnApply();
		}
	}

	if ( bLocked )
	{
		pDoc->VisGroups_LockUpdates( false );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handles <return> keys sent to OK -> apply instead
//-----------------------------------------------------------------------------
void CObjectProperties::OnOK(void)
{
	//VPROF_BUDGET( "CObjectProperties::OnClose", "Object Properties" );
	OnApply();
}

//-----------------------------------------------------------------------------
// Purpose: Handles the Apply button.
//-----------------------------------------------------------------------------
void CObjectProperties::OnCancel(void)
{
	ShowWindow(SW_HIDE);

	// reload original data and overwrite any changes made prio
	ReloadData();
}


//-----------------------------------------------------------------------------
// Purpose: Handles the input icon button.
//-----------------------------------------------------------------------------
void CObjectProperties::OnInputs(void)
{
	SetActivePage(m_pInput);
}


//-----------------------------------------------------------------------------
// Purpose: Handles the output icon button.
//-----------------------------------------------------------------------------
void CObjectProperties::OnOutputs(void)
{
	SetActivePage(m_pOutput);
}


//-----------------------------------------------------------------------------
// Purpose: handle the pushing of the Edit Instance button.  Will attempt to 
//			switch to the map document containing the instance.
// Input  : none
// Output : none
//-----------------------------------------------------------------------------
void CObjectProperties::OnEditInstance(void)
{
	if (m_DstObjects.Count() == 1)
	{
		CMapClass	*pObj = m_DstObjects.Element( 0 );
		CMapEntity	*pEntity = dynamic_cast< CMapEntity * >( pObj );

		if ( pEntity )
		{
			EnumChildrenPos_t	pos;
			CMapClass *pChild = pEntity->GetFirstDescendent( pos );
			while ( pChild != NULL )
			{
				CMapInstance *pMapInstance = dynamic_cast< CMapInstance * >( pChild );
				if ( pMapInstance != NULL )
				{
					OnClose();

					pMapInstance->SwitchTo();
				}

				pChild = pEntity->GetNextDescendent( pos );
			}
		}
	}

}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CObjectProperties::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	//VPROF_BUDGET( "CObjectProperties::OnCreate", "Object Properties" );

	lpCreateStruct->dwExStyle |= WS_EX_TOOLWINDOW;

	if (CPropertySheet::OnCreate(lpCreateStruct) == -1)
	{
		return -1;
	}

	return 0;
}

void CObjectProperties::SetObjectList(const CMapObjectList *pObjectList)
{
	m_pOrgObjects = pObjectList;
	MarkDataDirty();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectProperties::MarkDataDirty()
{
	//VPROF_BUDGET( "CObjectProperties::RefreshData", "Object Properties" );

	// if flag already set, dont touch anything
	if ( m_bDataDirty )
		return;

	for (int i = 0; i < m_nPages; i++)
	{
		if (m_ppPages[i]->m_hWnd)
		{
			m_ppPages[i]->RememberState();
			m_ppPages[i]->MarkDataDirty();
		}
	}

	Invalidate( false );

	m_DstObjects.RemoveAll();

	m_bDataDirty = true;
}