mirror of
https://github.com/alliedmodders/hl2sdk.git
synced 2024-12-23 01:59:43 +08:00
766 lines
20 KiB
C++
766 lines
20 KiB
C++
//========= 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 );
|
|
}
|