First version of the SOurce SDK 2013

1 files changed, 802 insertions, 0 deletions

diff --git a/mp/src/vgui2/vgui_controls/ScrollBar.cpp b/mp/src/vgui2/vgui_controls/ScrollBar.cpp
new file mode 100644
index 00000000..5330b41a
--- /dev/null
+++ b/mp/src/vgui2/vgui_controls/ScrollBar.cpp
@@ -0,0 +1,802 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+// $NoKeywords: $

+//=============================================================================//

+

+#include <assert.h>

+

+#include <vgui/IScheme.h>

+#include <vgui/ISystem.h>

+#include <vgui/IInput.h>

+#include <vgui/IImage.h>

+#include <KeyValues.h>

+

+#include <vgui_controls/ScrollBar.h>

+#include <vgui_controls/ScrollBarSlider.h>

+#include <vgui_controls/Button.h>

+#include <vgui_controls/Controls.h>

+#include <vgui_controls/ImagePanel.h>

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include <tier0/memdbgon.h>

+

+using namespace vgui;

+

+namespace

+{

+

+enum

+{						 // scroll bar will scroll a little, then continuous scroll like in windows

+	SCROLL_BAR_DELAY = 400,	 // default delay for all scroll bars

+	SCROLL_BAR_SPEED = 50, // this is how fast the bar scrolls when you hold down the arrow button

+	SCROLLBAR_DEFAULT_WIDTH = 17,

+};

+

+//-----------------------------------------------------------------------------

+// Purpose: Scroll bar button-the arrow button that moves the slider up and down.

+//-----------------------------------------------------------------------------

+class ScrollBarButton : public Button

+{

+public:

+	ScrollBarButton(Panel *parent, const char *panelName, const char *text) : Button(parent, panelName, text)

+	{

+		SetButtonActivationType(ACTIVATE_ONPRESSED);

+

+		SetContentAlignment(Label::a_center);

+	}

+

+	void OnMouseFocusTicked()

+	{

+		// pass straight up to parent

+		CallParentFunction(new KeyValues("MouseFocusTicked"));

+	}

+ 

+	virtual void ApplySchemeSettings(IScheme *pScheme)

+	{

+		Button::ApplySchemeSettings(pScheme);

+

+		SetFont(pScheme->GetFont("Marlett", IsProportional() ));

+		SetDefaultBorder(pScheme->GetBorder("ScrollBarButtonBorder"));

+        SetDepressedBorder(pScheme->GetBorder("ScrollBarButtonDepressedBorder"));

+		

+		SetDefaultColor(GetSchemeColor("ScrollBarButton.FgColor", pScheme), GetSchemeColor("ScrollBarButton.BgColor", pScheme));

+		SetArmedColor(GetSchemeColor("ScrollBarButton.ArmedFgColor", pScheme), GetSchemeColor("ScrollBarButton.ArmedBgColor", pScheme));

+		SetDepressedColor(GetSchemeColor("ScrollBarButton.DepressedFgColor", pScheme), GetSchemeColor("ScrollBarButton.DepressedBgColor", pScheme));

+	}

+

+	// Don't request focus.

+	// This will keep cursor focus in main window in text entry windows.

+	virtual void OnMousePressed(MouseCode code)

+	{

+		if (!IsEnabled())

+			return;

+		

+		if (!IsMouseClickEnabled(code))

+			return;

+		

+		if (IsUseCaptureMouseEnabled())

+		{

+			{

+				SetSelected(true);

+				Repaint();

+			}

+			

+			// lock mouse input to going to this button

+			input()->SetMouseCapture(GetVPanel());

+		}

+	}

+    virtual void OnMouseReleased(MouseCode code)

+    {

+		if (!IsEnabled())

+			return;

+		

+		if (!IsMouseClickEnabled(code))

+			return;

+		

+		if (IsUseCaptureMouseEnabled())

+		{

+			{

+				SetSelected(false);

+				Repaint();

+			}

+			

+			// lock mouse input to going to this button

+			input()->SetMouseCapture(NULL);

+		}

+

+		if( input()->GetMouseOver() == GetVPanel() )

+		{

+			SetArmed( true );

+		}

+    }

+

+};

+

+}

+

+vgui::Panel *ScrollBar_Vertical_Factory()

+{

+	return new ScrollBar(NULL, NULL, true );

+}

+

+vgui::Panel *ScrollBar_Horizontal_Factory()

+{

+	return new ScrollBar(NULL, NULL, false );

+}

+

+DECLARE_BUILD_FACTORY_CUSTOM_ALIAS( ScrollBar, ScrollBar_Vertical, ScrollBar_Vertical_Factory );

+DECLARE_BUILD_FACTORY_CUSTOM_ALIAS( ScrollBar, ScrollBar_Horizontal, ScrollBar_Horizontal_Factory );

+// Default is a horizontal one

+DECLARE_BUILD_FACTORY_CUSTOM( ScrollBar, ScrollBar_Horizontal_Factory );

+

+//-----------------------------------------------------------------------------

+// Purpose: Constructor

+//-----------------------------------------------------------------------------

+ScrollBar::ScrollBar(Panel *parent, const char *panelName, bool vertical) : Panel(parent, panelName)

+{

+	_slider=null;

+	_button[0]=null;

+	_button[1]=null;

+	_scrollDelay = SCROLL_BAR_DELAY;

+	_respond = true;

+	m_pUpArrow = NULL;

+	m_pLine = NULL;

+	m_pDownArrow = NULL;

+	m_pBox = NULL;

+	m_bNoButtons = false;

+	m_pOverriddenButtons[0] = NULL;

+	m_pOverriddenButtons[1] = NULL;

+

+	if (vertical)

+	{

+		// FIXME: proportional changes needed???

+		SetSlider(new ScrollBarSlider(NULL, "Slider", true));

+		SetButton(new ScrollBarButton(NULL, "UpButton", "t"), 0);

+		SetButton(new ScrollBarButton(NULL, "DownButton", "u"), 1);

+		_button[0]->SetTextInset(0, 1);

+		_button[1]->SetTextInset(0, -1);

+

+		SetSize(SCROLLBAR_DEFAULT_WIDTH, 64);

+	}

+	else

+	{

+		SetSlider(new ScrollBarSlider(NULL, NULL, false));

+		SetButton(new ScrollBarButton(NULL, NULL, "w"), 0);

+		SetButton(new ScrollBarButton(NULL, NULL, "4"), 1);

+		_button[0]->SetTextInset(0, 0);

+		_button[1]->SetTextInset(0, 0);

+

+		SetSize(64, SCROLLBAR_DEFAULT_WIDTH);

+	}

+

+	Panel::SetPaintBorderEnabled(true);

+	Panel::SetPaintBackgroundEnabled(false);

+	Panel::SetPaintEnabled(true);

+	SetButtonPressedScrollValue(20);

+	SetBlockDragChaining( true );

+

+	Validate();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: sets up the width of the scrollbar according to the scheme

+//-----------------------------------------------------------------------------

+void ScrollBar::ApplySchemeSettings(IScheme *pScheme)

+{

+	BaseClass::ApplySchemeSettings(pScheme);

+

+	const char *resourceString = pScheme->GetResourceString("ScrollBar.Wide");

+

+	if (resourceString)

+	{

+		int value = atoi(resourceString);

+		if (IsProportional())

+		{

+			value = scheme()->GetProportionalScaledValueEx(GetScheme(), value);

+		}

+

+		if (_slider && _slider->IsVertical())

+		{

+			// we're vertical, so reset the width

+			SetSize( value, GetTall() );

+		}

+		else

+		{

+			// we're horizontal, so the width means the height

+			SetSize( GetWide(), value );

+		}

+	}

+

+	UpdateButtonsForImages();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the slider's Paint border enabled.

+//-----------------------------------------------------------------------------

+void ScrollBar::SetPaintBorderEnabled(bool state)

+{

+	if ( _slider )

+	{

+		_slider->SetPaintBorderEnabled( state );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void ScrollBar::SetPaintBackgroundEnabled(bool state)

+{

+	if ( _slider )

+	{

+		_slider->SetPaintBackgroundEnabled( state );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void ScrollBar::SetPaintEnabled(bool state)

+{

+	if ( _slider )

+	{

+		_slider->SetPaintEnabled( state );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Layout the scroll bar and buttons on screen

+//-----------------------------------------------------------------------------

+void ScrollBar::PerformLayout()

+{

+	if (_slider)

+	{

+		int wide, tall;

+		GetPaintSize(wide,tall);

+		if(_slider->IsVertical())

+		{

+			if ( m_bNoButtons )

+			{

+				_slider->SetBounds(0, 0, wide, tall + 1);

+			}

+			else

+			{

+				_slider->SetBounds(0, wide, wide, tall-(wide*2)+1);

+				_button[0]->SetBounds(0,0, wide, wide );

+				_button[1]->SetBounds(0,tall-wide ,wide, wide );

+			}

+		}

+		else

+		{

+			if ( m_bNoButtons )

+			{

+				_slider->SetBounds(tall, 0, wide, tall + 1);

+			}

+			else

+			{

+				_slider->SetBounds(tall, -1, wide-(tall*2)+1, tall + 1 );

+				_button[0]->SetBounds(0, 0, tall, tall);

+				_button[1]->SetBounds(wide-tall, 0, tall, tall);

+			}

+		}

+

+		// Place the images over the appropriate controls

+		int x,y;

+		if ( m_pUpArrow )

+		{

+			_button[0]->GetBounds( x,y,wide,tall );

+			m_pUpArrow->SetBounds( x,y,wide,tall );

+		}

+		if ( m_pDownArrow )

+		{

+			_button[1]->GetBounds( x,y,wide,tall );

+			m_pDownArrow->SetBounds( x,y,wide,tall );

+		}

+		if ( m_pLine )

+		{

+			_slider->GetBounds( x,y,wide,tall );

+			m_pLine->SetBounds( x,y,wide,tall );

+		}

+		if ( m_pBox )

+		{

+			m_pBox->SetBounds( 0, wide, wide, wide );

+		}

+

+		_slider->MoveToFront();

+		// after resizing our child, we should remind it to perform a layout

+		_slider->InvalidateLayout();

+

+		UpdateSliderImages();

+	}

+

+	if ( m_bAutoHideButtons )

+	{

+		SetScrollbarButtonsVisible( _slider->IsSliderVisible() );

+	}

+

+	// get tooltips to draw

+	Panel::PerformLayout();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the value of the scroll bar slider.

+//-----------------------------------------------------------------------------

+void ScrollBar::SetValue(int value)

+{

+	_slider->SetValue(value);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the value of the scroll bar slider.

+//-----------------------------------------------------------------------------

+int ScrollBar::GetValue()

+{

+	return _slider->GetValue();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the range of the scroll bar slider.

+// This the range of numbers the slider can scroll through.

+//-----------------------------------------------------------------------------

+void ScrollBar::SetRange(int min,int max)

+{

+	_slider->SetRange(min,max);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Gets the range of the scroll bar slider.

+// This the range of numbers the slider can scroll through.

+//-----------------------------------------------------------------------------

+void ScrollBar::GetRange(int &min, int &max)

+{

+    _slider->GetRange(min, max);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Send a message when the slider is moved.

+// Input  : value - 

+//-----------------------------------------------------------------------------

+void ScrollBar::SendSliderMoveMessage(int value)

+{

+	PostActionSignal(new KeyValues("ScrollBarSliderMoved", "position", value));

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Called when the Slider is dragged by the user

+// Input  : value - 

+//-----------------------------------------------------------------------------

+void ScrollBar::OnSliderMoved(int value)

+{

+	SendSliderMoveMessage(value);

+	UpdateSliderImages();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Check if the scrollbar is vertical (true) or horizontal (false)

+//-----------------------------------------------------------------------------

+bool ScrollBar::IsVertical()

+{

+	return _slider->IsVertical();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Check if the the scrollbar slider has full range.

+// Normally if you have a scroll bar and the range goes from a to b and

+// the slider is sized to c, the range will go from a to b-c.

+// This makes it so the slider goes from a to b fully.

+//-----------------------------------------------------------------------------

+bool ScrollBar::HasFullRange()

+{

+	return _slider->HasFullRange();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Setup the indexed scroll bar button with the input params.

+//-----------------------------------------------------------------------------

+//LEAK: new and old slider will leak

+void ScrollBar::SetButton(Button *button, int index)

+{

+	if(_button[index]!=null)

+	{

+		_button[index]->SetParent((Panel *)NULL);

+	}

+	_button[index]=button;

+	_button[index]->SetParent(this);

+	_button[index]->AddActionSignalTarget(this);

+	_button[index]->SetCommand(new KeyValues("ScrollButtonPressed", "index", index));

+

+	Validate();

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Return the indexed scroll bar button

+//-----------------------------------------------------------------------------

+Button* ScrollBar::GetButton(int index)

+{

+	return _button[index];

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Set up the slider.

+//-----------------------------------------------------------------------------

+//LEAK: new and old slider will leak

+void ScrollBar::SetSlider(ScrollBarSlider *slider)

+{

+	if(_slider!=null)

+	{

+		_slider->SetParent((Panel *)NULL);

+	}

+	_slider=slider;

+	_slider->AddActionSignalTarget(this);

+	_slider->SetParent(this);

+

+	Validate();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Return a pointer to the slider.

+//-----------------------------------------------------------------------------

+ScrollBarSlider *ScrollBar::GetSlider()

+{

+	return _slider;

+}

+

+Button *ScrollBar::GetDepressedButton( int iIndex )

+{

+	if ( iIndex == 0 )

+		return ( m_pOverriddenButtons[0] ? m_pOverriddenButtons[0] : _button[0] );

+	return ( m_pOverriddenButtons[1] ? m_pOverriddenButtons[1] : _button[1] );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Scrolls in response to clicking and holding on up or down arrow

+// The idea is to have the slider move one step then delay a bit and then

+// the bar starts moving at normal speed. This gives a stepping feeling

+// to just clicking an arrow once.

+//-----------------------------------------------------------------------------

+void ScrollBar::OnMouseFocusTicked()

+{

+	int direction = 0;

+	

+	// top button is down

+	if ( GetDepressedButton(0)->IsDepressed() )

+	{

+		direction = -1;

+	}

+	// bottom top button is down

+	else if (GetDepressedButton(1)->IsDepressed())

+	{

+		direction = 1;

+	}

+

+	// a button is down 

+	if ( direction != 0 )  

+	{

+		RespondToScrollArrow(direction);

+		if (_scrollDelay < system()->GetTimeMillis())

+		{

+			_scrollDelay = system()->GetTimeMillis() + SCROLL_BAR_SPEED;

+			_respond = true; 

+		}

+		else

+		{

+			_respond = false; 

+		}		

+	}

+	// a button is not down.

+	else 

+	{

+		// if neither button is down keep delay at max

+		_scrollDelay = system()->GetTimeMillis() + SCROLL_BAR_DELAY;

+		_respond = true; 

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: move scroll bar in response to the first button

+// Input: button and direction to move scroll bar when that button is pressed

+//			direction can only by +/- 1 

+// Output: whether button is down or not

+//-----------------------------------------------------------------------------

+void ScrollBar::RespondToScrollArrow(int const direction)

+{

+	if (_respond)

+	{

+		int newValue = _slider->GetValue() + (direction * _buttonPressedScrollValue);

+		_slider->SetValue(newValue);

+		SendSliderMoveMessage(newValue);

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Trigger layout changes when the window size is changed.

+//-----------------------------------------------------------------------------

+void ScrollBar::OnSizeChanged(int wide, int tall)

+{

+	InvalidateLayout();

+	_slider->InvalidateLayout();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set how far the scroll bar slider moves when a scroll bar button is

+// pressed.

+//-----------------------------------------------------------------------------

+void ScrollBar::SetButtonPressedScrollValue(int value)

+{

+	_buttonPressedScrollValue=value;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the range of the rangewindow. This is how many 

+// lines are displayed at one time 

+// in the window the scroll bar is attached to.

+// This also controls the size of the slider, its size is proportional

+// to the number of lines displayed / total number of lines.

+//-----------------------------------------------------------------------------

+void ScrollBar::SetRangeWindow(int rangeWindow)

+{

+	_slider->SetRangeWindow(rangeWindow);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the range of the rangewindow. This is how many 

+// lines are displayed at one time 

+// in the window the scroll bar is attached to.

+// This also controls the size of the slider, its size is proportional

+// to the number of lines displayed / total number of lines.

+//-----------------------------------------------------------------------------

+int ScrollBar::GetRangeWindow()

+{

+	return _slider->GetRangeWindow();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void ScrollBar::Validate()

+{

+	if ( _slider != null )

+	{

+		int buttonOffset = 0;

+

+		for( int i=0; i<2; i++ )

+		{

+			if( _button[i] != null )

+			{

+				if( _button[i]->IsVisible() )

+				{

+					if( _slider->IsVertical() )

+					{					

+						buttonOffset += _button[i]->GetTall();

+					}

+					else

+					{

+						buttonOffset += _button[i]->GetWide();

+					}

+				}

+			}

+		}

+

+		_slider->SetButtonOffset(buttonOffset);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void ScrollBar::SetScrollbarButtonsVisible(bool visible)

+{

+	for( int i=0; i<2; i++ )

+	{

+		if( _button[i] != null )

+		{

+			_button[i]->SetShouldPaint( visible );

+			_button[i]->SetEnabled( visible );

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void ScrollBar::UseImages( const char *pszUpArrow, const char *pszDownArrow, const char *pszLine, const char *pszBox )

+{

+	if ( pszUpArrow )

+	{

+		if ( !m_pUpArrow )

+		{

+			m_pUpArrow = new vgui::ImagePanel( this, "UpArrow" );

+			if ( m_pUpArrow )

+			{

+				m_pUpArrow->SetImage( pszUpArrow );

+				m_pUpArrow->SetShouldScaleImage( true );

+				m_pUpArrow->SetFgColor( Color( 255, 255, 255, 255 ) );

+				m_pUpArrow->SetAlpha( 255 );

+				m_pUpArrow->SetZPos( -1 );

+			}

+		}

+

+		m_pUpArrow->SetImage( pszUpArrow );

+		m_pUpArrow->SetRotation( IsVertical() ? ROTATED_UNROTATED : ROTATED_CLOCKWISE_90 );

+	}

+	else if ( m_pUpArrow )

+	{

+		m_pUpArrow->DeletePanel();

+		m_pUpArrow = NULL;

+	}

+

+	if ( pszDownArrow )

+	{

+		if ( !m_pDownArrow )

+		{

+			m_pDownArrow = new vgui::ImagePanel( this, "DownArrow" );

+			if ( m_pDownArrow )

+			{

+				m_pDownArrow->SetShouldScaleImage( true );

+				m_pDownArrow->SetFgColor( Color( 255, 255, 255, 255 ) );

+				m_pDownArrow->SetAlpha( 255 );

+				m_pDownArrow->SetZPos( -1 );

+			}

+		}

+

+		m_pDownArrow->SetImage( pszDownArrow );

+		m_pDownArrow->SetRotation( IsVertical() ? ROTATED_UNROTATED : ROTATED_CLOCKWISE_90 );

+	}

+	else if ( m_pDownArrow )

+	{

+		m_pDownArrow->DeletePanel();

+		m_pDownArrow = NULL;

+	}

+

+	if ( pszLine )

+	{

+		if ( !m_pLine )

+		{

+			m_pLine = new ImagePanel( this, "Line" );

+			if ( m_pLine )

+			{

+				m_pLine->SetShouldScaleImage( true );

+				m_pLine->SetZPos( -1 );

+			}

+		}

+

+		m_pLine->SetImage( pszLine );

+		m_pLine->SetRotation( IsVertical() ? ROTATED_UNROTATED : ROTATED_CLOCKWISE_90 );

+	}

+	else if ( m_pLine )

+	{

+		m_pLine->DeletePanel();

+		m_pLine = NULL;

+	}

+

+	if ( pszBox )

+	{

+		if ( !m_pBox )

+		{

+			m_pBox = new ImagePanel( this, "Box" );

+			if ( m_pBox )

+			{

+				m_pBox->SetShouldScaleImage( true );

+				m_pBox->SetZPos( -1 );

+			}

+		}

+

+		m_pBox->SetImage( pszBox );

+		m_pBox->SetRotation( IsVertical() ? ROTATED_UNROTATED : ROTATED_CLOCKWISE_90 );

+	}

+	else if ( m_pBox )

+	{

+		m_pBox->DeletePanel();

+		m_pBox = NULL;

+	}

+

+	UpdateButtonsForImages();

+	InvalidateLayout();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void ScrollBar::UpdateButtonsForImages( void )

+{

+	// Turn off parts of our drawing based on which images we're replacing it with

+	if ( m_pUpArrow || m_pDownArrow )

+	{

+		SetScrollbarButtonsVisible( false );

+		_button[0]->SetPaintBorderEnabled( false );

+		_button[1]->SetPaintBorderEnabled( false );

+		m_bAutoHideButtons = false;

+	}

+	if ( m_pLine || m_pBox )

+	{

+		SetPaintBackgroundEnabled( false );

+		SetPaintBorderEnabled( false );

+

+		if ( _slider )

+		{

+			_slider->SetPaintEnabled( false );

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void ScrollBar::UpdateSliderImages( void )

+{

+	if ( m_pUpArrow && m_pDownArrow )

+	{

+		// set the alpha on the up arrow

+		int nMin, nMax;

+		GetRange( nMin, nMax );

+		int nScrollPos = GetValue();

+		int nRangeWindow = GetRangeWindow();

+		int nBottom = nMax - nRangeWindow;

+		if ( nBottom < 0 )

+		{

+			nBottom = 0;

+		}

+

+		// set the alpha on the up arrow

+		int nAlpha = ( nScrollPos - nMin <= 0 ) ? 90 : 255;

+		m_pUpArrow->SetAlpha( nAlpha );

+

+		// set the alpha on the down arrow

+		nAlpha = ( nScrollPos >= nBottom ) ? 90 : 255;

+		m_pDownArrow->SetAlpha( nAlpha );

+	}

+

+	if ( m_pLine && m_pBox )

+	{

+		ScrollBarSlider *pSlider = GetSlider();

+		if ( pSlider && pSlider->GetRangeWindow() > 0 )

+		{

+			int x, y, w, t, min, max;

+			m_pLine->GetBounds( x, y, w, t );

+

+			// If our slider needs layout, force it to do it now

+			if ( pSlider->IsLayoutInvalid() )

+			{

+				pSlider->InvalidateLayout( true );

+			}

+			pSlider->GetNobPos( min, max );

+

+			if ( IsVertical() )

+			{

+				m_pBox->SetBounds( x, y + min, w, ( max - min ) );

+			}

+			else

+			{

+				m_pBox->SetBounds( x + min, 0, (max-min), t );

+			}

+		}

+	}

+}

+void ScrollBar::ApplySettings( KeyValues *pInResourceData )

+{

+	BaseClass::ApplySettings( pInResourceData );

+

+	m_bNoButtons = pInResourceData->GetBool( "nobuttons", false );

+

+	KeyValues *pSliderKV = pInResourceData->FindKey( "Slider" );

+	if ( pSliderKV && _slider )

+	{

+		_slider->ApplySettings( pSliderKV );

+	}

+

+	KeyValues *pDownButtonKV = pInResourceData->FindKey( "DownButton" );

+	if ( pDownButtonKV && _button[0] )

+	{

+		_button[0]->ApplySettings( pDownButtonKV );

+	}

+

+	KeyValues *pUpButtonKV = pInResourceData->FindKey( "UpButton" );

+	if ( pUpButtonKV && _button[0] )

+	{

+		_button[1]->ApplySettings( pUpButtonKV );

+	}

+}