|
|
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: The document. Exposes functions for object creation, deletion, and
// manipulation. Holds the current tool. Handles GUI messages that are
// view-independent.
//
//=============================================================================//
#include "stdafx.h"
#include "Selection.h"
#include "mapdoc.h"
#include "MapHelper.h"
#include "MapSolid.h"
#include "Manifest.h"
#include "mapdefs.h"
#include "globalfunctions.h"
#include "mainfrm.h"
#include "objectproperties.h"
CSelection::CSelection(void) { m_pDocument = NULL; }
CSelection::~CSelection(void) {
}
void CSelection::Init( CMapDoc *pDocument ) { m_pDocument = pDocument; m_eSelectMode = selectGroups; m_SelectionList.Purge(); ClearHitList();
m_LastValidBounds.bmins = Vector(0, 0, 0); m_LastValidBounds.bmaxs = Vector(64, 64, 64);
UpdateSelectionBounds(); }
bool CSelection::IsSelected(CMapClass *pobj) { return (m_SelectionList.Find(pobj) != m_SelectionList.InvalidIndex()); }
void CSelection::GetLastValidBounds(Vector &vecMins, Vector &vecMaxs) { vecMins = m_LastValidBounds.bmins; vecMaxs = m_LastValidBounds.bmaxs; }
bool CSelection::GetBounds(Vector &vecMins, Vector &vecMaxs) { if ( m_bBoundsDirty ) UpdateSelectionBounds();
if ( m_SelectionList.Count() == 0) return false;
vecMins = m_Bounds.bmins; vecMaxs = m_Bounds.bmaxs;
return true;; }
bool CSelection::GetLogicalBounds(Vector2D &vecMins, Vector2D &vecMaxs) { if ( m_bBoundsDirty ) UpdateSelectionBounds();
if ( m_SelectionList.Count() == 0) return false;
vecMins = m_vecLogicalMins; vecMaxs = m_vecLogicalMaxs;
return true; }
//-----------------------------------------------------------------------------
// Purpose: Used for translations. Uses entity origins and brush bounds.
// That way, when moving stuff, the entity origins will stay on the grid.
//-----------------------------------------------------------------------------
void CSelection::GetBoundsForTranslation( Vector &vecMins, Vector &vecMaxs ) { vecMins.Init( COORD_NOTINIT, COORD_NOTINIT, 0 ); vecMaxs.Init( -COORD_NOTINIT, -COORD_NOTINIT, 0 );
for (int i = 0; i < m_SelectionList.Count(); i++) { CMapClass *pobj = m_SelectionList[i];
// update physical bounds
Vector mins, maxs; CEditGameClass *pEdit = dynamic_cast< CEditGameClass* >( pobj ); if ( (pEdit && pEdit->IsSolidClass()) || dynamic_cast<CMapSolid *>(pobj) ) { pobj->GetRender2DBox(mins, maxs); } else { pobj->GetOrigin( mins ); maxs = mins; } VectorMin( mins, vecMins, vecMins ); VectorMax( maxs, vecMaxs, vecMaxs ); } }
void CSelection::UpdateSelectionBounds( void ) { m_Bounds.ResetBounds(); m_vecLogicalMins[0] = m_vecLogicalMins[1] = COORD_NOTINIT; m_vecLogicalMaxs[0] = m_vecLogicalMaxs[1] = -COORD_NOTINIT; for (int i = 0; i < m_SelectionList.Count(); i++) { CMapClass *pobj = m_SelectionList[i];
// update physical bounds
Vector mins,maxs; pobj->GetRender2DBox(mins, maxs); m_Bounds.UpdateBounds(mins, maxs);
// update logical bounds
Vector2D logicalMins,logicalMaxs; pobj->GetRenderLogicalBox( logicalMins, logicalMaxs ); Vector2DMin( logicalMins, m_vecLogicalMins, m_vecLogicalMins ); Vector2DMax( logicalMaxs, m_vecLogicalMaxs, m_vecLogicalMaxs ); }
// remeber bounds if valid
if ( m_Bounds.IsValidBox() ) { m_LastValidBounds = m_Bounds; }
m_bBoundsDirty = false; }
bool CSelection::GetBoundsCenter(Vector &vecCenter) { if ( m_bBoundsDirty ) UpdateSelectionBounds();
if ( m_SelectionList.Count() == 0 ) return false;
m_Bounds.GetBoundsCenter( vecCenter );
return true; }
bool CSelection::GetLogicalBoundsCenter( Vector2D &vecCenter ) { if ( m_bBoundsDirty ) UpdateSelectionBounds();
if ( m_SelectionList.Count() == 0 ) return false;
vecCenter = (m_vecLogicalMins+m_vecLogicalMaxs)/2;
return true; }
bool CSelection::IsEmpty() { return m_SelectionList.Count() == 0; }
const CMapObjectList *CSelection::GetList() { return &m_SelectionList; }
const CMapObjectList* CSelection::GetHitList() { return &m_HitList; }
int CSelection::GetCount() { return m_SelectionList.Count(); }
//-----------------------------------------------------------------------------
// Purpose: Returns the current selection mode. The selection mode determines
// what gets selected when the user clicks on something - the group,
// the entity, or the solid.
//-----------------------------------------------------------------------------
SelectMode_t CSelection::GetMode() { return m_eSelectMode; }
void CSelection::SetSelectionState(SelectionState_t eSelectionState) { for ( int i=0; i<m_SelectionList.Count(); i++ ) { CMapEntity *pObject = (CMapEntity *)m_SelectionList.Element(i); pObject->SetSelectionState( eSelectionState ); } }
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CSelection::IsAnEntitySelected(void) { if (m_SelectionList.Count() > 0) { int nSelCount = m_SelectionList.Count(); for (int i = 0; i < nSelCount; i++) { CMapClass *pObject = m_SelectionList.Element(i); CMapEntity *pEntity = dynamic_cast <CMapEntity *> (pObject); if (pEntity != NULL) { return true; } } }
return false; }
//-----------------------------------------------------------------------------
// Purpose: Returns true if the selection is editable. Every object must be
// individually editable for this routine to return true.
//-----------------------------------------------------------------------------
bool CSelection::IsEditable() { if ( m_SelectionList.Count() > 0 ) { int nSelCount = m_SelectionList.Count(); for (int i = 0; i < nSelCount; i++) { CMapClass *pObject = m_SelectionList.Element(i);
if ( pObject->IsEditable() == false ) { return false; } } }
return true; }
//-----------------------------------------------------------------------------
// Purpose: Returns true if the selection is copyable. CManifestInstance classes
// are not copyable.
//-----------------------------------------------------------------------------
bool CSelection::IsCopyable() { if ( m_SelectionList.Count() > 0 ) { int nSelCount = m_SelectionList.Count(); for (int i = 0; i < nSelCount; i++) { CMapClass *pObject = m_SelectionList.Element(i);
if ( pObject->IsMapClass( MAPCLASS_TYPE( CManifestInstance ) ) ) { return false; } } }
return true; }
//-----------------------------------------------------------------------------
// Purpose: Sets the current selection mode, which determines which objects
// are selected when the user clicks on things.
//-----------------------------------------------------------------------------
void CSelection::SetMode(SelectMode_t eNewSelectMode) { SelectMode_t eOldSelectMode = m_eSelectMode; m_eSelectMode = eNewSelectMode; if ((eOldSelectMode == selectSolids) || ((eOldSelectMode == selectObjects) && (eNewSelectMode == selectGroups))) { //
// If we are going from a more specific selection mode to a less specific one,
// clear the selection. This avoids unexpectedly selecting new things.
//
SelectObject(NULL, scClear|scSaveChanges); } else { //
// Put all the children of the selected objects in a list, along with their children.
//
CMapObjectList NewList; int nSelCount = m_SelectionList.Count(); for (int i = 0; i < nSelCount; i++) { CMapClass *pObject = m_SelectionList[i]; AddLeavesToListCallback(pObject, &NewList); pObject->EnumChildren((ENUMMAPCHILDRENPROC)AddLeavesToListCallback, (DWORD)&NewList); }
SelectObject(NULL, scClear|scSaveChanges);
//
// Add child objects to selection.
//
for (int pos=0;pos<NewList.Count();pos++) { CMapClass *pObject = NewList[pos]; CMapClass *pSelObject = pObject->PrepareSelection(eNewSelectMode); if (pSelObject) { SelectObject(pSelObject, scSelect); } } } }
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObject -
//-----------------------------------------------------------------------------
void CSelection::AddHit(CMapClass *pObject) { if ( m_HitList.Find(pObject) == -1 ) { m_HitList.AddToTail(pObject); } }
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSelection::ClearHitList(void) { m_HitList.RemoveAll(); m_iCurHit = -1; }
bool CSelection::RemoveAll(void) { for ( int i=0;i<m_SelectionList.Count(); i++ ) { CMapClass *pObject = m_SelectionList.Element(i); pObject->SetSelectionState(SELECT_NONE); }
m_SelectionList.RemoveAll(); SetBoundsDirty();
return true; }
bool CSelection::RemoveDead(void) { bool bFoundOne = false; for ( int i=m_SelectionList.Count()-1; i>=0; i-- ) { CMapClass *pObject = m_SelectionList.Element(i); if (!pObject->GetParent()) { m_SelectionList.FastRemove(i); pObject->SetSelectionState(SELECT_NONE); bFoundOne = true; } }
// TODO check if we do the same as in SelectObject
SetBoundsDirty();
return bFoundOne; }
//-----------------------------------------------------------------------------
// Purpose: Removes objects that are not visible from the selection set.
//-----------------------------------------------------------------------------
bool CSelection::RemoveInvisibles(void) { bool bFoundOne = false;
for ( int i=m_SelectionList.Count()-1; i>=0; i-- ) { CMapClass *pObject = m_SelectionList.Element(i); if ( !pObject->IsVisible() ) { m_SelectionList.FastRemove(i); pObject->SetSelectionState(SELECT_NONE); bFoundOne = true; } }
SetBoundsDirty();
return bFoundOne; }
//-----------------------------------------------------------------------------
// Purpose:
// Input : iIndex -
// bUpdateViews -
//-----------------------------------------------------------------------------
void CSelection::SetCurrentHit(int iIndex, bool bCascading) { if ( m_HitList.Count() == 0) { Assert( m_iCurHit == -1); return; }
// save & toggle old selection off
if (m_iCurHit != -1) { CMapClass *pObject = m_HitList[m_iCurHit]; SelectObject(pObject, scToggle|scSaveChanges); }
if (iIndex == hitNext) { // hit next object
m_iCurHit++; } else if (iIndex == hitPrev) { // hit prev object
m_iCurHit--; } else { m_iCurHit = iIndex; }
// make sure curhit is valid
if (m_iCurHit >= m_HitList.Count()) { m_iCurHit = 0; } else if (m_iCurHit < 0) { m_iCurHit = m_HitList.Count() - 1; }
CMapClass *pObject = m_HitList[m_iCurHit];
if ( bCascading ) { // Build actual selection list based on cascading...
CUtlRBTree< CMapClass*, unsigned short > tree( 0, 0, DefLessFunc( CMapClass* ) ); bool bRecursive = false; // not used yet
m_pDocument->BuildCascadingSelectionList( pObject, tree, bRecursive ); CMapObjectList list; list.AddToTail( pObject ); bool bRootIsSelected = IsSelected(pObject); bool bUniformSelectionState = true; for ( unsigned short h = tree.FirstInorder(); h != tree.InvalidIndex(); h = tree.NextInorder(h) ) { list.AddToTail( list[h] ); if ( IsSelected( list[h] ) != bRootIsSelected ) { bUniformSelectionState = false; } }
/* Change toggle to select or unselect if we're toggling and cascading
// but the root + children have different selection state
if ( ( !bUniformSelectionState ) && ( cmd == scToggle ) ) { cmd = bRootIsSelected ? scSelect : scUnselect; }*/
SelectObjectList( &list, scSelect ); } else { SelectObject(pObject, scToggle ); } }
//-----------------------------------------------------------------------------
// Purpose:
// Input : pobj -
// cmd -
//-----------------------------------------------------------------------------
bool CSelection::SelectObject(CMapClass *pObj, int cmd) { // if no object is given we only can execute the clear command
if ( pObj == NULL ) { // check if selection is already empty
if (m_SelectionList.Count() == 0) return false; // nothing to do
if ( cmd & scClear ) { RemoveAll(); } } else // object oriented operation
{ int iIndex = m_SelectionList.Find(pObj); bool bAlreadySelected = iIndex != -1; if ( cmd & scToggle ) { if ( bAlreadySelected ) cmd |= scUnselect; else cmd |= scSelect; }
if ( cmd & scSelect ) { if ( cmd & scClear ) { // if we re-selected the only selected element, nothing changes
if ( bAlreadySelected && m_SelectionList.Count() == 1 ) return false;
RemoveAll(); bAlreadySelected = false; // reset that flag
}
if ( bAlreadySelected ) return false; m_SelectionList.AddToTail(pObj); pObj->SetSelectionState(SELECT_NORMAL); } else if ( (cmd & scUnselect) && bAlreadySelected ) { // ok unselect an yet selected object
m_SelectionList.Remove(iIndex); pObj->SetSelectionState(SELECT_NONE); } else { return false; // nothing was changed
} }
// ok something in the selection was changed, set dirty flags
SetBoundsDirty();
if ( cmd & scSaveChanges ) { // changing the selection automatically saves changes made to the properties dialog
GetMainWnd()->pObjectProperties->SaveData(); }
// always mark data dirty
GetMainWnd()->pObjectProperties->MarkDataDirty();
// uddate all views
m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_SELECTION ); return true; }
//-----------------------------------------------------------------------------
// Purpose: Clears the current selection and selects everything in the given list.
// Input : pList - Objects to select.
//-----------------------------------------------------------------------------
void CSelection::SelectObjectList( const CMapObjectList *pList, int cmd ) { // Clear the current selection.
// Clear the current selection.
if ( cmd & scSaveChanges ) { GetMainWnd()->pObjectProperties->SaveData(); cmd &= ~scSaveChanges; }
if ( cmd & scClear ) { RemoveAll(); cmd &= ~scClear; }
if ( pList != NULL ) { for (int pos=0;pos<pList->Count();pos++) { CMapClass *pObject = pList->Element(pos); CMapClass *pSelObject = pObject->PrepareSelection( m_eSelectMode ); if (pSelObject) { SelectObject( pSelObject, cmd ); } } } }
|