source-engine/vgui2/vgui_controls/Splitter.cpp

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

#include <vgui/IScheme.h>
#include <vgui/Cursor.h>
#include <vgui/IInput.h>
#include <vgui_controls/Splitter.h>
#include "tier1/KeyValues.h"
#include <limits.h>

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

using namespace vgui;


enum
{
	SPLITTER_HANDLE_WIDTH = 4
};


//-----------------------------------------------------------------------------
// Splitter handle
//-----------------------------------------------------------------------------
namespace vgui
{

class SplitterHandle : public Panel
{
	DECLARE_CLASS_SIMPLE( SplitterHandle, Panel );

public:
	SplitterHandle( Splitter *parent, const char *name, SplitterMode_t mode, int nIndex );
	~SplitterHandle();

	virtual void ApplySchemeSettings( IScheme *pScheme );
	virtual void OnMousePressed( MouseCode code );
	virtual void OnMouseReleased( MouseCode code );
	virtual void OnCursorMoved( int x, int y );
	virtual void OnMouseDoublePressed( MouseCode code );

private:
	SplitterMode_t m_nMode;
	int m_nIndex;
	bool m_bDragging;
};

} // end namespace vgui

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
SplitterHandle::SplitterHandle( Splitter *parent, const char *name, SplitterMode_t mode, int nIndex ) : BaseClass( parent, name )
{
	int w, h;
	parent->GetSize( w, h );

	if ( mode == SPLITTER_MODE_HORIZONTAL )
	{
		SetSize( w, SPLITTER_HANDLE_WIDTH );
		SetCursor( dc_sizens );
	}
	else
	{
		SetSize( SPLITTER_HANDLE_WIDTH, h );
		SetCursor( dc_sizewe );
	}

	SetVisible( true );
	SetPaintBackgroundEnabled( false );
	SetPaintEnabled( false );
	SetPaintBorderEnabled( true );
	m_bDragging = false;
	m_nIndex = nIndex;
	m_nMode = mode;
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
SplitterHandle::~SplitterHandle()
{
}


//-----------------------------------------------------------------------------
// Scheme settings
//-----------------------------------------------------------------------------
void SplitterHandle::ApplySchemeSettings(IScheme *pScheme)
{
	// Cache off background color stored in SetSplitterColor
	Color c = GetBgColor();
	SetBorder(pScheme->GetBorder("ButtonDepressedBorder"));
	BaseClass::ApplySchemeSettings(pScheme);
	SetBgColor( c );
}


//-----------------------------------------------------------------------------
// Capture mouse when dragging
//-----------------------------------------------------------------------------
void SplitterHandle::OnMousePressed(MouseCode code)
{
	if ( !m_bDragging )
	{
		input()->SetMouseCapture(GetVPanel());
		m_bDragging = true;
	}
}


//-----------------------------------------------------------------------------
// Release mouse capture when finished dragging
//-----------------------------------------------------------------------------
void SplitterHandle::OnMouseReleased(MouseCode code)
{
	if ( m_bDragging )
	{
		input()->SetMouseCapture(NULL);
		m_bDragging = false;
	}
}


//-----------------------------------------------------------------------------
// While dragging, update the splitter position
//-----------------------------------------------------------------------------
void SplitterHandle::OnCursorMoved(int x, int y)
{
	if (m_bDragging)
	{
		input()->GetCursorPos( x, y );
		Splitter *pSplitter = assert_cast<Splitter*>( GetParent() );
		pSplitter->ScreenToLocal( x,y );
		pSplitter->SetSplitterPosition( m_nIndex, (m_nMode == SPLITTER_MODE_HORIZONTAL) ? y : x );
	}
}


//-----------------------------------------------------------------------------
// Double-click: make both panels on either side of the splitter equal size
//-----------------------------------------------------------------------------
void SplitterHandle::OnMouseDoublePressed( MouseCode code )
{
	Splitter *pSplitter = assert_cast<Splitter*>( GetParent() );
	pSplitter->EvenlyRespaceSplitters();
}



//-----------------------------------------------------------------------------
// Returns a panel that chains user configs
//-----------------------------------------------------------------------------
namespace vgui
{

class SplitterChildPanel : public EditablePanel
{
	DECLARE_CLASS_SIMPLE( SplitterChildPanel, EditablePanel );

public:
	SplitterChildPanel( Panel *parent, const char *panelName ) : BaseClass( parent, panelName )
	{
		SetPaintBackgroundEnabled( false );
		SetPaintEnabled( false );
		SetPaintBorderEnabled( false );
	}

	virtual ~SplitterChildPanel() {}

	// Children may have user config settings
	bool HasUserConfigSettings()
	{
		return true;
	}
};

} // end namespace vgui

//-----------------------------------------------------------------------------
//
// Splitter panel
//
//-----------------------------------------------------------------------------
vgui::Panel *Splitter_V_Factory()
{
	return new Splitter( NULL, NULL, SPLITTER_MODE_VERTICAL, 1 );
}

vgui::Panel *Splitter_H_Factory()
{
	return new Splitter( NULL, NULL, SPLITTER_MODE_HORIZONTAL, 1 );
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
Splitter::Splitter( Panel *parent, const char *name, SplitterMode_t mode, int nCount ) : BaseClass( parent, name )
{
	Assert( nCount >= 1 );
	m_Mode = mode;

	SetPaintBackgroundEnabled( false );
	SetPaintEnabled( false );
	SetPaintBorderEnabled( false );

	RecreateSplitters( nCount );

	EvenlyRespaceSplitters();
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
Splitter::~Splitter()
{
	m_Splitters.RemoveAll();
}

void Splitter::RecreateSplitters( int nCount )
{
	int i;
	int c = m_Splitters.Count();
	for ( i = 0; i < c; ++i )
	{
		delete m_Splitters[ i ].m_pPanel;
		delete m_Splitters[ i ].m_pHandle;
	}
	m_Splitters.RemoveAll();

	for ( i = 0; i < (nCount + 1); ++i )
	{
		char pBuffer[512];
		Q_snprintf( pBuffer, sizeof(pBuffer), "child%d", i );

		int nIndex = m_Splitters.AddToTail( );
		SplitterChildPanel *pEditablePanel = new SplitterChildPanel( this, pBuffer );
		m_Splitters[nIndex].m_pPanel = pEditablePanel;
		m_Splitters[nIndex].m_bLocked = false;
		m_Splitters[nIndex].m_nLockedSize = 0;
	}

	// We do this in 2 loops so that the first N children are actual child panels
	for ( i = 0; i < nCount; ++i )
	{
		SplitterHandle *pHandle = new SplitterHandle( this, "SplitterHandle", m_Mode, i );
		m_Splitters[i].m_pHandle = pHandle;
		pHandle->MoveToFront();
	}
	m_Splitters[nCount].m_pHandle = NULL;
}


//-----------------------------------------------------------------------------
// Sets the splitter color
//-----------------------------------------------------------------------------
void Splitter::SetSplitterColor( Color c )
{
	int nCount = m_Splitters.Count() - 1;
	if ( c.a() != 0 )
	{
		for ( int i = 0; i < nCount; ++i )
		{
			m_Splitters[i].m_pHandle->SetBgColor( c );
			m_Splitters[i].m_pHandle->SetPaintBackgroundEnabled( true );
		}
	}
	else
	{
		for ( int i = 0; i < nCount; ++i )
		{
			m_Splitters[i].m_pHandle->SetPaintBackgroundEnabled( false );
		}
	}
}

	
//-----------------------------------------------------------------------------
// Enables borders on the splitters
//-----------------------------------------------------------------------------
void Splitter::EnableBorders( bool bEnable )
{
	int nCount = m_Splitters.Count() - 1;
	for ( int i = 0; i < nCount; ++i )
	{
		m_Splitters[i].m_pHandle->SetPaintBorderEnabled( bEnable );
	}
}


//-----------------------------------------------------------------------------
// controls splitters
//-----------------------------------------------------------------------------
int Splitter::GetSplitterCount() const
{
	return m_Splitters.Count() - 1;
}


//-----------------------------------------------------------------------------
// controls splitters
//-----------------------------------------------------------------------------
int Splitter::GetSubPanelCount() const
{
	return m_Splitters.Count();
}


//-----------------------------------------------------------------------------
// Purpose: Applies resouce settings
//-----------------------------------------------------------------------------
void Splitter::ApplySettings(KeyValues *inResourceData)
{
	BaseClass::ApplySettings(inResourceData);

	// Look for splitter positions
	int nSplitterCount = GetSplitterCount();
	for ( int i = 0; i < nSplitterCount; ++i )
	{
		char pBuffer[512];
		Q_snprintf( pBuffer, sizeof(pBuffer), "splitter%d", i );

		int nSplitterPos = inResourceData->GetInt( pBuffer , -1 );
		if ( nSplitterPos >= 0 )
		{
			SetSplitterPosition( i, nSplitterPos );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int Splitter::GetPosRange()
{
	int w, h;
	GetSize( w, h );
	int nPosRange = (m_Mode == SPLITTER_MODE_HORIZONTAL) ? h : w;
	return nPosRange;
}


//-----------------------------------------------------------------------------
// Locks the size of a particular child in pixels.
//-----------------------------------------------------------------------------
void Splitter::LockChildSize( int nChildIndex, int nSize )
{
	Assert( nChildIndex < m_Splitters.Count() );
	SplitterInfo_t &info = m_Splitters[nChildIndex];
	nSize += SPLITTER_HANDLE_WIDTH;
	if ( !info.m_bLocked || (info.m_nLockedSize != nSize) )
	{ 
		float flPrevPos = (nChildIndex > 0) ? m_Splitters[nChildIndex-1].m_flPos : 0.0f;
		float flOldSize = info.m_flPos - flPrevPos;
		float flDelta = nSize - flOldSize;
		int nCount = m_Splitters.Count();
		for ( int i = nChildIndex; i < nCount-1; ++i )
		{
			m_Splitters[i].m_flPos += flDelta;
		}
		m_Splitters[nCount-1].m_flPos = GetPosRange();

		info.m_bLocked = true;
		info.m_nLockedSize = nSize;
		InvalidateLayout();
	}
}

void Splitter::UnlockChildSize( int nChildIndex )
{
	Assert( nChildIndex < m_Splitters.Count() );
	SplitterInfo_t &info = m_Splitters[nChildIndex]; 
	if ( info.m_bLocked )
	{
		info.m_bLocked = false;

		float flPrevPos = (nChildIndex > 0) ? m_Splitters[nChildIndex-1].m_flPos : 0.0f;
		float flBelowSize = GetPosRange() - flPrevPos;

		int nLockedSize = ComputeLockedSize( nChildIndex + 1 );
		int nUnlockedCount = 1;
		int nCount = m_Splitters.Count();
		for ( int i = nChildIndex + 1; i < nCount; ++i )
		{
			if ( !m_Splitters[i].m_bLocked )
			{
				++nUnlockedCount;
			}
		}

		float flUnlockedSize = ( flBelowSize - nLockedSize ) / nUnlockedCount;

		for ( int i = nChildIndex; i < nCount; ++i )
		{
			if ( !m_Splitters[i].m_bLocked )
			{
				m_Splitters[i].m_flPos = flPrevPos + flUnlockedSize;
			}
			else
			{
				m_Splitters[i].m_flPos = flPrevPos + m_Splitters[i].m_nLockedSize;
			}
			flPrevPos = m_Splitters[i].m_flPos; 
		}
		InvalidateLayout();
	}
}


//-----------------------------------------------------------------------------
// Called when size changes
//-----------------------------------------------------------------------------
void Splitter::OnSizeChanged( int newWide, int newTall )
{
	BaseClass::OnSizeChanged( newWide, newTall );

	// Don't resize if it's degenerate and won't show up anyway...
	if ( newTall <= 0 || newWide <= 0 )
		return;

	int nLockedSize = 0;
	float flUnlockedSize = 0.0f;
	int nCount = m_Splitters.Count();
	float flLastPos = 0.0f;
	int nUnlockedCount = 0;
	for ( int i = 0; i < nCount; ++i )
	{
		SplitterInfo_t &info = m_Splitters[i];
		if ( info.m_bLocked )
		{
			nLockedSize += info.m_nLockedSize;
		}
		else
		{
			++nUnlockedCount;
			flUnlockedSize += info.m_flPos - flLastPos; 
		}
		flLastPos = info.m_flPos;
	}

	int nNewTotalSize = (m_Mode == SPLITTER_MODE_HORIZONTAL) ? newTall : newWide;
	int nNewUnlockedSize = nNewTotalSize - nLockedSize;
	if ( nNewUnlockedSize < nUnlockedCount * SPLITTER_HANDLE_WIDTH )
	{
		nNewUnlockedSize = nUnlockedCount * SPLITTER_HANDLE_WIDTH;
	}

	float flRatio = nNewUnlockedSize / flUnlockedSize;
	float flLastPrevPos = 0.0f;
	flLastPos = 0.0f;
	for ( int i = 0; i < nCount - 1; ++i )
	{
		SplitterInfo_t &info = m_Splitters[i];
		if ( info.m_bLocked )
		{
			flLastPrevPos = info.m_flPos; 
			info.m_flPos = flLastPos + info.m_nLockedSize;
		}
		else
		{
			float flNewSize = info.m_flPos - flLastPrevPos;
			flNewSize *= flRatio;
			flLastPrevPos = info.m_flPos; 
			info.m_flPos = flLastPos + flNewSize;
		}
		flLastPos = info.m_flPos;
	}

	// Clamp the bottom to 1.0
	m_Splitters[nCount-1].m_flPos = nNewTotalSize;
}


//-----------------------------------------------------------------------------
// Splitter position
//-----------------------------------------------------------------------------
int Splitter::GetSplitterPosition( int nIndex )
{
	return (int)( m_Splitters[nIndex].m_flPos + 0.5f );
}

void Splitter::SetSplitterPosition( int nIndex, int nPos )
{
	int nPosRange = GetPosRange();
	if ( nPosRange == 0 )
		return;

	// If we're locked to a sibling, move the previous sibling first
	while ( ( nIndex >= 0 ) && m_Splitters[nIndex].m_bLocked )
	{
		nPos -= m_Splitters[nIndex].m_nLockedSize;
		--nIndex;
	}
	if ( nIndex < 0 )
		return;

	// Clamp to the valid positional range
	int i;
	int nMinPos = 0;
	for ( i = 0; i < nIndex; ++i )
	{
		if ( !m_Splitters[i].m_bLocked )
		{
			nMinPos += SPLITTER_HANDLE_WIDTH;
		}
		else
		{
			nMinPos += m_Splitters[i].m_nLockedSize;
		}
	}

	int nMaxPos = nPosRange - SPLITTER_HANDLE_WIDTH;
	int c = GetSplitterCount();
	for ( i = nIndex + 1; i < c; ++i )
	{
		if ( !m_Splitters[i].m_bLocked )
		{
			nMaxPos -= SPLITTER_HANDLE_WIDTH;
		}
		else
		{
			nMaxPos -= m_Splitters[i].m_nLockedSize;
		}
	}
	nPos = clamp( nPos, nMinPos, nMaxPos );
	
	m_Splitters[nIndex].m_flPos = nPos;
	int p = nPos;
	for ( i = nIndex - 1 ; i >= 0; --i )
	{
		int nMinPrevPos;
		int nMaxPrevPos;
		if ( !m_Splitters[i+1].m_bLocked )
		{
			nMinPrevPos = -INT_MAX;
			nMaxPrevPos = nPos - SPLITTER_HANDLE_WIDTH;
		}
		else
		{
			nMinPrevPos = nMaxPrevPos = p - m_Splitters[i+1].m_nLockedSize;
		}

		int nCurPos = GetSplitterPosition( i );
		if ( nMaxPrevPos < nCurPos || nMinPrevPos > nCurPos  )
		{
			m_Splitters[ i ].m_flPos = nMaxPrevPos;
			p = nMaxPrevPos;
		}
		else
		{
			p = m_Splitters[ i ].m_flPos;
		}
	}

	for ( i = nIndex + 1 ; i < c; ++i )
	{
		int nMinNextPos;
		int nMaxNextPos;
		if ( !m_Splitters[i].m_bLocked )
		{
			nMinNextPos = nPos + SPLITTER_HANDLE_WIDTH;
			nMaxNextPos = INT_MAX;
		}
		else
		{
			nMinNextPos = nMaxNextPos = nPos + m_Splitters[i].m_nLockedSize;
		}

		int nCurPos = GetSplitterPosition( i );
		if ( nMinNextPos > nCurPos || nMaxNextPos < nCurPos )
		{
			m_Splitters[ i ].m_flPos = nMinNextPos;
			nPos = nMinNextPos;
		}
		else
		{
			nPos = m_Splitters[ i ].m_flPos;
		}
	}

	InvalidateLayout();
}


//-----------------------------------------------------------------------------
// Computes the locked size
//-----------------------------------------------------------------------------
int Splitter::ComputeLockedSize( int nStartingIndex )
{
	int nLockedSize = 0;
	int nCount = m_Splitters.Count();
	for ( int i = nStartingIndex; i < nCount; ++i )
	{
		if ( m_Splitters[i].m_bLocked )
		{
			nLockedSize += m_Splitters[i].m_nLockedSize;
		}
	}
	return nLockedSize;
}


//-----------------------------------------------------------------------------
// Evenly respaces all the splitters
//-----------------------------------------------------------------------------
void Splitter::EvenlyRespaceSplitters( )
{
	int nSplitterCount = GetSubPanelCount();
	if ( nSplitterCount == 0 )
		return;

	int nLockedSize = ComputeLockedSize( 0 );
	float flUnlockedSize = (float)( GetPosRange() - nLockedSize );
	float flDPos = flUnlockedSize / (float)nSplitterCount;
	if ( flDPos < SPLITTER_HANDLE_WIDTH )
	{
		flDPos = SPLITTER_HANDLE_WIDTH;
	}
	float flPos = 0.0f;
	for ( int i = 0; i  < nSplitterCount; ++i )
	{
		if ( !m_Splitters[i].m_bLocked )
		{
			flPos += flDPos;
		}
		else
		{
			flPos += m_Splitters[i].m_nLockedSize;
		}
		m_Splitters[i].m_flPos = flPos;
	}

	InvalidateLayout();
}

void Splitter::RespaceSplitters( float *flFractions )
{
	int nSplitterCount = GetSubPanelCount();
	if ( nSplitterCount == 0 )
		return;

	float flPos = 0.0f;
	int nPosRange = GetPosRange();
	for ( int i = 0; i  < nSplitterCount; ++i )
	{
		flPos += flFractions[i];
		m_Splitters[i].m_flPos = flPos * nPosRange;
	}

	Assert( flPos == 1.0f );

	InvalidateLayout();
}


//-----------------------------------------------------------------------------
// Purpose: sets user settings
//-----------------------------------------------------------------------------
void Splitter::ApplyUserConfigSettings(KeyValues *userConfig)
{ 
	BaseClass::ApplyUserConfigSettings( userConfig );

	// read the splitter sizes
	int c = m_Splitters.Count();
	float *pFractions = (float*)_alloca( c * sizeof(float) );
	float flTotalSize = 0.0f;
	for ( int i = 0; i < c; i++ )
	{
		char name[128];
		_snprintf(name, sizeof(name), "%d_splitter_pos", i);
		pFractions[i] = userConfig->GetFloat( name, flTotalSize + SPLITTER_HANDLE_WIDTH + 1 );
		flTotalSize = pFractions[i];
	}

	if ( flTotalSize != 0.0f )
	{
		int nPosRange = GetPosRange();
		for ( int i = 0; i < c; ++i )
		{
			pFractions[i] /= flTotalSize;
			m_Splitters[i].m_flPos = pFractions[i] * nPosRange;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: returns user config settings for this control
//-----------------------------------------------------------------------------
void Splitter::GetUserConfigSettings(KeyValues *userConfig)
{
	BaseClass::GetUserConfigSettings( userConfig );

	// save which columns are hidden
	int c = m_Splitters.Count();
	for ( int i = 0 ; i < c; i++ )
	{
		char name[128];
		_snprintf(name, sizeof(name), "%d_splitter_pos", i);
		userConfig->SetFloat( name, m_Splitters[i].m_flPos );
	}
}


//-----------------------------------------------------------------------------
// Called to perform layout
//-----------------------------------------------------------------------------
void Splitter::PerformLayout( )
{
	BaseClass::PerformLayout();

	int nSplitterCount = GetSubPanelCount();
	if ( nSplitterCount == 0 )
		return;

	int w, h;
	GetSize( w, h );

	int nLastPos = 0;
	for ( int i	= 0; i < nSplitterCount; ++i )
	{
		Panel *pChild = m_Splitters[i].m_pPanel;
		SplitterHandle *pHandle = m_Splitters[i].m_pHandle;
		int nSplitterPos = (int)( m_Splitters[i].m_flPos + 0.5f );

		if ( m_Mode == SPLITTER_MODE_HORIZONTAL )
		{
			pChild->SetPos( 0, nLastPos );
			pChild->SetSize( w, nSplitterPos - nLastPos );
			if ( pHandle )
			{
				pHandle->SetPos( 0, nSplitterPos );
				pHandle->SetSize( w, SPLITTER_HANDLE_WIDTH );
			}
		}
		else
		{
			pChild->SetPos( nLastPos, 0 );
			pChild->SetSize( nSplitterPos - nLastPos, h );
			if ( pHandle )
			{
				pHandle->SetPos( nSplitterPos, 0 );
				pHandle->SetSize( SPLITTER_HANDLE_WIDTH, h );
			}
		}

		nLastPos = nSplitterPos + SPLITTER_HANDLE_WIDTH;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void Splitter::GetSettings( KeyValues *outResourceData )
{
	BaseClass::GetSettings( outResourceData );
}