1HEADmaster

25 files changed, 4900 insertions, 0 deletions

diff --git a/public/panorama/controls/animatedimagestrip.h b/public/panorama/controls/animatedimagestrip.h
new file mode 100644
index 0000000..77f8fa8
--- /dev/null
+++ b/public/panorama/controls/animatedimagestrip.h
@@ -0,0 +1,69 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef ANIMATED_IMAGE_STRIP_H
+#define ANIMATED_IMAGE_STRIP_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "image.h"
+
+namespace panorama
+{
+	
+//-----------------------------------------------------------------------------
+// Purpose: Animated Image Strip
+//
+// Takes an image that has multiple sub-frames and animates displaying them.
+// Accepts strips in either horizontal or vertical orientation.
+//-----------------------------------------------------------------------------
+class CAnimatedImageStrip : public CImagePanel
+{
+	DECLARE_PANEL2D( CAnimatedImageStrip, CImagePanel );
+
+public:
+	CAnimatedImageStrip( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CAnimatedImageStrip();
+
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+
+	virtual void Paint() OVERRIDE;
+
+	void StartAnimating();
+	
+	void StopAnimating();
+	void StopAnimatingAtFrame( int nFrame );
+
+	int GetDefaultFrame() const { return m_nDefaultFrame; }
+	void SetDefaultFrame( int nFrame ) { m_nDefaultFrame = nFrame; }
+
+	float GetFrameTime() const { return m_flFrameTime; }
+	void SetFrameTime( float flFrameTime ) { m_flFrameTime = flFrameTime; }
+
+	void SetCurrentFrame( int nFrame );
+	int GetCurrentFrame() const { return m_nCurrentFrameIndex; }
+
+	int GetFrameCount();
+
+private:
+	void AdvanceFrame();
+	int GetFrameIndex( int nFrame );
+
+	bool EventPanelLoaded( const CPanelPtr< IUIPanel > &panelPtr );
+	bool EventAdvanceFrame();
+
+	int m_nDefaultFrame;
+	float m_flFrameTime;
+	int m_nCurrentFrameIndex;
+	int m_nStopAtFrameIndex;
+	bool m_bAnimating;
+	bool m_bCurrentFramePainted;
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_BUTTON_H
diff --git a/public/panorama/controls/button.h b/public/panorama/controls/button.h
new file mode 100644
index 0000000..8710698
--- /dev/null
+++ b/public/panorama/controls/button.h
@@ -0,0 +1,113 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_BUTTON_H
+#define PANORAMA_BUTTON_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "label.h"
+
+namespace panorama
+{
+
+class CLabel;
+
+//-----------------------------------------------------------------------------
+// Purpose: Button
+//-----------------------------------------------------------------------------
+class CButton : public CPanel2D
+{
+	DECLARE_PANEL2D( CButton, CPanel2D );
+
+public:
+	CButton( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CButton();
+
+	// clone
+	virtual bool IsClonable() { return AreChildrenClonable(); }
+	virtual CPanel2D *Clone();
+
+	// events
+	bool EventActivated( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+
+protected:
+	virtual void InitClonedPanel( CPanel2D *pPanel );
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: ToggleButton
+//-----------------------------------------------------------------------------
+class CToggleButton : public CButton
+{
+	DECLARE_PANEL2D( CToggleButton, CButton );
+
+public:
+	CToggleButton( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CToggleButton();
+
+	void SetSelected( bool bSelected );
+	void SetText( const char *pchText );
+	virtual bool OnKeyTyped( const KeyData_t &unichar );
+
+	// events
+	virtual bool EventActivated( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+
+	virtual void SetupJavascriptObjectTemplate() OVERRIDE;
+
+	virtual const char *PchGetText() const { return m_pLabel ? m_pLabel->PchGetText() : ""; }	
+
+protected:
+	virtual bool BSetProperties( const CUtlVector< ParsedPanelProperty_t > &vecProperties );	
+
+	CPanel2D *m_pButton;
+	CLabel *m_pLabel;
+	CLabel::ETextType m_eTextType;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: RadioButton
+//-----------------------------------------------------------------------------
+class CRadioButton : public CButton
+{
+	DECLARE_PANEL2D( CRadioButton, CButton );
+
+public:
+	void SetSelected( bool bSelected );
+	void SetText( const char *pchText );
+	const char *GetGroup() { return m_sGroup.String(); }
+	void SetGroup( const char *pchGroup ) { m_sGroup = pchGroup; }
+
+	virtual bool BSetProperties( const CUtlVector< ParsedPanelProperty_t > &vecProperties );
+
+public:
+	CRadioButton( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CRadioButton();
+
+	// events:
+
+	// i have been activated
+	bool EventActivated( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+
+	// the specified radio, member of the specified group, has been activated (broadcast)
+	bool EventOtherActivated( const CPanelPtr< IUIPanel > &pPanel, const char *szGroup );
+
+protected:
+	void FireSelectionEvent();
+
+	CPanel2D *m_pButton;
+	CLabel *m_pLabel;
+	CLabel::ETextType m_eTextType;
+	CUtlString m_sGroup;
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_BUTTON_H
diff --git a/public/panorama/controls/carousel.h b/public/panorama/controls/carousel.h
new file mode 100644
index 0000000..58bbca6
--- /dev/null
+++ b/public/panorama/controls/carousel.h
@@ -0,0 +1,232 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef CAROUSEL_H
+#define CAROUSEL_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "mathlib/mathlib.h"
+#include "mathlib/beziercurve.h"
+#include "panel2d.h"
+#include "panorama/controls/label.h"
+#include "panorama/controls/mousescroll.h"
+
+namespace panorama
+{
+
+DECLARE_PANORAMA_EVENT0( ResetCarouselMouseWheelCounts );
+DECLARE_PANORAMA_EVENT1( SetCarouselSelectedChild, CPanelPtr<CPanel2D> );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Button
+//-----------------------------------------------------------------------------
+class CCarousel : public CPanel2D
+{
+	DECLARE_PANEL2D( CCarousel, CPanel2D );
+
+public:
+	CCarousel( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CCarousel();
+
+	enum EFocusType
+	{
+		k_EFocusTypeLeft,
+		k_EFocusTypeEdge,
+		k_EFocusTypeCenter
+	};
+
+	void SetTitleText( const char *pchTitle );
+	void SetTitleVisible( bool bVisible );
+	void SetWrap( bool bWrap );
+	void SetFocusType( EFocusType eType );
+	void SetOffset( CUILength len );
+	void DrawFocusFrame( bool bDraw );
+	void DeleteChildren();
+	
+	bool SetFocusToIndex( int iFocus );
+	int GetFocusIndex() const { return GetChildIndex( m_pFocusedChild.Get() ); }
+	CPanel2D *GetFocusChild() const { return m_pFocusedChild.Get(); }
+
+	// Sets the child that will get focus when the carousel has focus. Remembered between focus calls
+	void SetSelectedChild( CPanel2D *pPanel );
+
+	// Sets the panel for which focus state is checked when applying focus offset.
+	void SetFocusOffsetPanel( CPanel2D *pPanel ) { m_ptrPanelFocusOffset = pPanel; }
+
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+	virtual void GetDebugPropertyInfo( CUtlVector< DebugPropertyOutput_t *> *pvecProperties );
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+	virtual void Paint();
+
+	virtual bool OnMoveRight( int nRepeats );
+	virtual bool OnMoveLeft( int nRepeats );
+	virtual bool OnTabForward( int nRepeats ) { return OnMoveRight( nRepeats ); }
+	virtual bool OnTabBackward( int nRepeats ) { return OnMoveLeft( nRepeats ); }
+	virtual bool OnMouseWheel( const panorama::MouseData_t &code );
+	virtual void OnStylesChanged();
+
+	virtual void OnUIScaleFactorChanged( float flScaleFactor ) OVERRIDE;
+
+	virtual bool BRequiresContentClipLayer() OVERRIDE { return true; }
+
+	virtual void OnInitializedFromLayout();
+
+	virtual void SetupJavascriptObjectTemplate() OVERRIDE;
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName );
+#endif
+
+protected:
+
+	virtual bool OnSetFocusToNextPanel( int nRepeats, EFocusMoveDirection moveType, bool bAllowWrap, float flTabIndexCurrent, float flXPosCurrent, float flYPosCurrent, float flXStart, float fYStart ) OVERRIDE
+	{
+		if ( m_bWrap )
+		{
+			switch( moveType )
+			{
+			case k_ENextInTabOrder:
+			case k_ENextByXPosition:
+				return OnMoveRight( nRepeats );
+			case k_EPrevInTabOrder:
+			case k_EPrevByXPosition:
+				return OnMoveLeft( nRepeats );
+			default:
+				break;
+			}
+		}
+		else
+		{
+			int iFocusChild = GetChildIndex( m_pFocusedChild.Get() );
+			switch( moveType )
+			{
+			case k_ENextInTabOrder:
+			case k_ENextByXPosition:
+				if ( iFocusChild < GetChildCount() - 1 )
+				{
+					return OnMoveRight( nRepeats );
+				}
+				break;
+			case k_EPrevInTabOrder:
+			case k_EPrevByXPosition:
+				if ( iFocusChild > 0 )
+				{
+					return OnMoveLeft( nRepeats );
+				}
+				break;
+			default:
+				break;
+			}
+		}
+
+		return false;
+	}
+
+	// child management
+	virtual void OnBeforeChildrenChanged();
+	virtual void OnCallBeforeStyleAndLayout() { UpdateFocusAndDirtyChildStyles(); }
+
+private:
+	enum EFocusEdge
+	{
+		k_EFocusEdgeLeft,
+		k_EFocusEdgeRight
+	};
+
+	// event handlers
+	bool EventInputFocusSet( const CPanelPtr< IUIPanel > &ptrPanel );
+	bool EventInputFocusLost( const CPanelPtr< IUIPanel > &ptrPanel );
+	bool OnResetMouseWheelCounts();
+	bool EventCarouselMouseScroll( const CPanelPtr< IUIPanel > &ptrPanel, int cRepeat );
+	bool EventWindowCursorShown( IUIWindow *pWindow );
+	bool EventWindowCursorHidden( IUIWindow *pWindow );
+
+	// owned panels
+	CLabel *CreateTitleLabel();
+
+	// focus
+	bool BSetFocusToChild( CPanel2D *pPanel );
+	void MarkFocusDirty();
+	bool UpdateFocusAndDirtyChildStyles();
+
+	// helpers
+	int GetPreviousWrapPanel( int i );
+	int GetNextWrapPanel( int i );
+	float GetFinalChildWidth( CPanel2D *pChild, float flContainerHeight );
+	void GetFinalChildDimensions( float *pflWidth, float *pflHeight, CPanel2D *pChild, float flContainerHeight );		
+	int CalcIndexDistanceBetweenPanels( int iLHS, int iRHS );
+	int GetNextPanelInLayout( int iStart );
+	int GetPreviousPanelInLayout( int iStart );
+	void AddCarouselStyle( CPanel2D *pChild, int iChild, int iCurrentFocus );
+	void RemoveCarouselStyle( CPanel2D *pChild, int iChild, int iCurrentFocus );
+	void RegisterForCursorChanges();
+	void UnregisterForCursorChanges();
+
+	// configured offets
+	void GetPanelOffsets( CUILength *plenX, CUILength *plenY, CUILength *plenZ, int nDistanceFromFocus, float flWidth, float flHeight );
+	CUILength GetPanelOffset( int nDistanceFromFocus, bool bUseFocus, const CUtlVector< CUILength > &vecOffsets, const CUtlVector< CUILength > &vecFocusOffsets );
+
+	// layout related
+	void GetLayoutStart( int iFocusChild, float *pflOffset, float flLeft, float flCarouselOffset, const float flContainerWidth, const float flContainerHeight );
+	void LayoutChildPanels( int iFocusChild, float flOffset, float flLeft, float flRight, const float flContainerWidth, const float flContainerHeight, const CUtlVector< CPanel2D* > &vecNewChildren );
+	bool BPositionPanelRight( int iPanel, int nDistanceFromFocus, float *pflOffset, float flLeft, float flContainerWidth, float flContainerHeight, bool bCheckFits, const CUtlVector< CPanel2D* > &vecNewChildren );
+	bool BPositionPanelLeft( int iPanel, int nDistanceFromFocus, float *pflOffset, float flLeft, float flContainerWidth, float flContainerHeight, bool bCheckFits, const CUtlVector< CPanel2D* > &vecNewChildren );
+	void LayoutMouseScrollRegions( float flFinalWidth, float flFinalHeight );
+	
+	struct DirtyChildStyles_t
+	{
+		int m_iOriginalFocus;
+		CUtlVector< CPanel2D* > m_vecPanels;
+	};
+	DirtyChildStyles_t *m_pDirtyChildStyles;
+
+
+	CLabel *m_pTitleLabel;
+	CMouseScrollRegion *m_pLeftMouseScrollRegion;
+	CMouseScrollRegion *m_pRightMouseScrollRegion;
+	CPanelPtr< CPanel2D > m_pFocusedChild;
+
+	EFocusType m_eFocusType;
+	bool m_bWrap;
+	CUILength m_lenOffset;
+	bool m_bIncludeScale2d;
+
+	// for edge focus
+	EFocusEdge m_eLastFocusEdge;
+	int m_iFocusLastEdge;
+
+	struct ChildOffsets_t
+	{
+		CUtlVector< CUILength > x;
+		CUtlVector< CUILength > y;
+		CUtlVector< CUILength > z;
+	};
+	ChildOffsets_t m_childOffsets;
+	ChildOffsets_t m_childOffsetsFocus;	
+	bool m_bFlowingLayout;
+	bool m_bHadFocus;
+
+	double m_flLastMouseWheel;
+	uint32 m_unMouseWheelCount;
+
+	double m_flLastMove;
+	bool m_bDelayedMovePosted;
+	bool m_bRegisteredForCursorChanges;
+	
+	bool m_bShuffleIntoView;
+
+	int32 m_nPanelsVisible;
+
+	CPanelPtr< CPanel2D > m_ptrPanelFocusOffset;
+};
+
+
+} // namespace panorama
+
+#endif // CAROUSEL_H
diff --git a/public/panorama/controls/contextmenu.h b/public/panorama/controls/contextmenu.h
new file mode 100644
index 0000000..bbb5451
--- /dev/null
+++ b/public/panorama/controls/contextmenu.h
@@ -0,0 +1,78 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef CONTEXTMENU_H
+#define CONTEXTMENU_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panorama/controls/panel2d.h"
+
+DECLARE_PANEL_EVENT1( ContextMenuEvent, const char * )
+DECLARE_PANEL_EVENT1( ContextMenuEventDirect, panorama::IUIEvent * );
+
+namespace panorama 
+{
+
+//-----------------------------------------------------------------------------
+// Purpose: Helper class to derive from for creating context menus
+//-----------------------------------------------------------------------------
+class CContextMenu : public panorama::CPanel2D
+{
+	DECLARE_PANEL2D( CContextMenu, panorama::CPanel2D );
+
+public:
+	CContextMenu( CPanel2D *pParent, const char *pchName, CPanel2D *pEventParent );
+	CContextMenu( IUIWindow *pParent, const char *pchName, CPanel2D *pEventParent );
+	virtual ~CContextMenu();
+	virtual bool OnClick( IUIPanel *pPanel, const panorama::MouseData_t &code );
+
+	void SetMenuTarget( const CPanelPtr< IUIPanel >& targetPanelPtr );
+
+	void CalculatePosition() { m_bReposition = true; InvalidateSizeAndPosition(); }
+
+protected:
+	CPanel2D *GetEventParent() { return m_pEventParent; }
+
+private:
+	void Initialize( CPanel2D *pEventParent );
+
+	void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+
+	bool OnFireEvent( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel, const char *pchEventText );
+	bool OnFireEvent( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel, IUIEvent *pEvent );
+	bool OnCancelled( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel, panorama::EPanelEventSource_t eSource );
+
+	CPanel2D *m_pEventParent;
+	CPanelPtr< IUIPanel > m_pMenuTarget;
+	double m_flCreateTime;
+	bool m_bReposition;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Helper class for simple context menus that doesn't require derivation
+//-----------------------------------------------------------------------------
+class CSimpleContextMenu : public panorama::CContextMenu
+{
+	DECLARE_PANEL2D( CSimpleContextMenu, panorama::CContextMenu );
+
+public:
+	CSimpleContextMenu( CPanel2D *pParent, const char *pchName, CPanel2D *pEventParent  );
+	CSimpleContextMenu( IUIWindow *pParent, const char *pchName, CPanel2D *pEventParent  );
+	virtual ~CSimpleContextMenu();
+
+	void AddMenuItem( const char *pchLabelText, const char *pchEventText );
+	void AddMenuItemEvent( const char *pchLabel, IUIEvent *pEvent );
+
+private:
+
+};
+
+} // namespace panorama
+
+#endif // CONTEXTMENU_H
\ No newline at end of file
diff --git a/public/panorama/controls/dropdown.h b/public/panorama/controls/dropdown.h
new file mode 100644
index 0000000..f756bd5
--- /dev/null
+++ b/public/panorama/controls/dropdown.h
@@ -0,0 +1,137 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_DROPDOWN_H
+#define PANORAMA_DROPDOWN_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+
+namespace panorama
+{
+
+DECLARE_PANEL_EVENT0( DropDownSelectionChanged );
+DECLARE_PANORAMA_EVENT2( DropDownMenuClosed, bool, CPanelPtr< CPanel2D > );
+
+class CDropDownMenu;
+
+//-----------------------------------------------------------------------------
+// Purpose: Drop Down Control
+//-----------------------------------------------------------------------------
+class CDropDown : public CPanel2D
+{
+	DECLARE_PANEL2D( CDropDown, CPanel2D );
+
+public:
+	CDropDown( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CDropDown();
+
+	virtual void SetupJavascriptObjectTemplate() OVERRIDE;
+
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+	void AddOption( CPanel2D *pPanel );
+	bool HasOption( const char *pchID );
+	void RemoveOption( const char *pchID );
+	void RemoveAllOptions();
+
+	void FindOptionIDsByClass( const char *pchClassName, CUtlVector< CUtlString > &vecIDsOut );
+	void SortOptions( int( __cdecl *pfnCompare )(const ClientPanelPtr_t *, const ClientPanelPtr_t *) );
+
+	CPanel2D *GetSelected() { return m_pSelected.Get(); }
+	void SetSelected( const char *pchID, bool bNotify );
+	void SetSelected( const char *pchID ) { return SetSelected( pchID, true ); }
+	void SetDefault( const char *pchID ) { m_strDefaultSelection.Set( pchID ); }
+	void ResetToDefault( bool bNotify );
+
+	CPanel2D *AccessDropDownMenu() { return (CPanel2D*)m_pMenu.Get(); }
+
+	virtual bool OnMouseButtonDown( const MouseData_t &mouseData );
+	virtual bool OnClick( IUIPanel *pPanel, const MouseData_t &code );
+	virtual void OnResetToDefaultValue();
+	
+	// Call if you know you've changed the contents of one of the option panels
+	void InvalidateOptions( bool bForceReload );
+
+	CPanel2D *FindDropDownMenuChild( const char *pchID );
+	virtual bool BIsClientPanelEvent( CPanoramaSymbol symProperty ) OVERRIDE;
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
+#endif
+
+protected:
+	bool EventPanelActivated( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+	bool EventDropDownMenuClosed( bool bSelectionChanged, CPanelPtr< CPanel2D > pPanel );
+	bool EventResetToDefault( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel );
+
+	virtual void OnInitializedFromLayout();
+	void ShowMenu();
+	void UpdateSelectedChild( bool bSuppressChangedEvent, bool bInvalidateAlways = false );
+
+	virtual void OnStylesChanged() OVERRIDE;
+
+	CPanelPtr< CDropDownMenu > GetMenu() { return m_pMenu; }
+
+private:
+	CPanelPtr< CDropDownMenu >m_pMenu;
+	CPanelPtr<CPanel2D> m_pSelected;
+	bool m_bSuppressClick;
+
+	CUtlString m_strInitialSelection;
+	CUtlString m_strDefaultSelection;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Drop Down Menu (shown when activated)
+//-----------------------------------------------------------------------------
+class CDropDownMenu : public CPanel2D
+{
+	DECLARE_PANEL2D( CDropDownMenu, CPanel2D );
+
+public:
+	CDropDownMenu( CDropDown *pDropDown, const char * pchPanelID );
+	virtual ~CDropDownMenu();
+
+	void Show();
+	void Close() { Hide( false ); }
+
+	CPanel2D *GetSelectedChild();
+	void SetSelected( const char *pchID );
+	void AddOption( CPanel2D *pPanel );
+	bool HasOption( const char *pchID );
+	void RemoveOption( const char *pchID );
+	void RemoveAll();
+
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+	virtual void OnResetToDefaultValue();
+	virtual IUIPanel *GetLocalizationParent() const { return m_pDropDown->UIPanel(); }
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
+#endif
+
+protected:
+	bool EventPanelActivated( const CPanelPtr< IUIPanel > &ptrPanel, EPanelEventSource_t eSource );
+	bool EventCancelled( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+	bool EventInputFocusTopLevelChanged( CPanelPtr< CPanel2D > ptrPanel );
+	bool EventResetToDefault( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel );
+	bool EventInputFocusSet( const panorama::CPanelPtr< IUIPanel > &ptrPanel );
+
+private:
+	void Hide( bool bSelectionChanged );
+
+	CDropDown *m_pDropDown;
+	CPanel2D *m_pSelectedChild;
+};
+
+
+} // namespace panorama
+
+#endif // PANORAMA_DROPDOWN_H
diff --git a/public/panorama/controls/edgescroller.h b/public/panorama/controls/edgescroller.h
new file mode 100644
index 0000000..46b820f
--- /dev/null
+++ b/public/panorama/controls/edgescroller.h
@@ -0,0 +1,63 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef EDGE_SCROLLER_H
+#define EDGE_SCROLLER_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panorama/controls/panel2d.h"
+
+namespace panorama
+{
+
+class CEdgeScrollBar;
+class CUIEdgeScrollBar;
+class CButton;
+
+//-----------------------------------------------------------------------------
+// Purpose: Control that shows buttons on the edges to scroll rather than a normal scroll bar
+//-----------------------------------------------------------------------------
+class CEdgeScroller : public CPanel2D
+{
+	DECLARE_PANEL2D( CEdgeScroller, CPanel2D );
+
+public:
+	CEdgeScroller( CPanel2D *pParent, const char *pchID );
+	virtual ~CEdgeScroller();
+
+	// Callback to client panel to create a scrollbar
+	virtual IUIScrollBar *CreateNewVerticalScrollBar( float flInitialScrollPos ) OVERRIDE;
+	virtual IUIScrollBar *CreateNewHorizontalScrollBar( float flInitialScrollPos ) OVERRIDE;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Scrollbar that just shows buttons on the edges of the panel rather than an actual Scrollbar
+//-----------------------------------------------------------------------------
+class CEdgeScrollBar : public CBaseScrollBar
+{
+	DECLARE_PANEL2D( CEdgeScrollBar, CBaseScrollBar );
+
+public:
+	CEdgeScrollBar( CPanel2D *pParent, const char *pchID, bool bHorizontal );
+	virtual ~CEdgeScrollBar();
+
+protected:
+	virtual void UpdateLayout( bool bImmediateMove ) OVERRIDE;
+
+private: 
+	bool m_bHorizontal;
+
+	CButton *m_pMinButton;
+	CButton *m_pMaxButton;
+};
+
+
+} // namespace panorama
+
+#endif // EDGE_SCROLLER_H
diff --git a/public/panorama/controls/fileopendialog.h b/public/panorama/controls/fileopendialog.h
new file mode 100644
index 0000000..79dc451
--- /dev/null
+++ b/public/panorama/controls/fileopendialog.h
@@ -0,0 +1,224 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_FILEOPENDIALOG_H
+#define PANORAMA_FILEOPENDIALOG_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "../uievent.h"
+#include "panorama/controls/button.h"
+
+namespace panorama
+{
+
+class CDropDown;
+class CLabel;
+class CTextEntry;
+class CFileOpenDialogEntry;
+
+DECLARE_PANORAMA_EVENT0( FileOpenDialogOpen );
+DECLARE_PANORAMA_EVENT0( FileOpenDialogCancel );
+DECLARE_PANORAMA_EVENT0( FileOpenDialogClose );
+DECLARE_PANORAMA_EVENT0( FileOpenDialogFolderUp );
+DECLARE_PANEL_EVENT1( FileOpenDialogSortByColumn, int );
+DECLARE_PANEL_EVENT1( FileOpenDialogSelectFile, uint32 );
+DECLARE_PANEL_EVENT1( FileOpenDialogDoubleClickFile, uint32 );
+DECLARE_PANORAMA_EVENT0( FileOpenDialogFullPathChanged );
+DECLARE_PANORAMA_EVENT0( FileOpenDialogFilterChanged );
+DECLARE_PANEL_EVENT1( FileOpenDialogFilesSelected, const char * );
+
+//-----------------------------------------------------------------------------
+// Purpose: generic open/save as file dialog, by default deletes itself on close
+//-----------------------------------------------------------------------------
+enum FileOpenDialogType_t
+{
+	FOD_SAVE = 0,
+	FOD_OPEN,
+	FOD_SELECT_DIRECTORY,
+	FOD_OPEN_MULTIPLE,
+};
+
+struct FileData_t
+{
+	CUtlString		m_FileAttributes;
+	CUtlString		m_CreationTime;
+	int64			m_nCreationTime;
+	CUtlString		m_LastAccessTime;
+	CUtlString		m_LastWriteTime;
+	int64			m_nLastWriteTime;
+	int64			m_nFileSize;
+	CUtlString		m_FileName;
+	CUtlString		m_FullPath;
+	CUtlString		m_FileType;
+
+	bool			m_bDirectory;
+};
+
+enum FileOpenDialogSorting_t
+{
+	FOD_SORT_NAME = 0,
+	FOD_SORT_SIZE,
+	FOD_SORT_TYPE,
+	FOD_SORT_DATE_MODIFIED
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: FileOpenDialog
+//-----------------------------------------------------------------------------
+class CFileOpenDialog : public CPanel2D
+{
+	DECLARE_PANEL2D( CFileOpenDialog, CPanel2D );
+
+public:
+	CFileOpenDialog( CPanel2D *parent, const char * pchPanelID, FileOpenDialogType_t type );
+	CFileOpenDialog( panorama::IUIWindow *pParent, const char * pchPanelID, FileOpenDialogType_t type );
+	virtual ~CFileOpenDialog();
+
+	// Set the directory the file search starts in
+	void SetStartDirectory(const char *dir);
+
+	// Sets the start directory context (and resets the start directory in the process)
+	// NOTE: If you specify a startdir context, then if you've already opened
+	// a file with that same start dir context before, it will start in the
+	// same directory it ended up in.
+	void SetStartDirectoryContext( const char *pContext, const char *pDefaultDir );
+
+	// Add filters for the drop down combo box
+	// The filter info, if specified, gets sent back to the app in the FileSelected message
+	void AddFilter( const char *filter, const char *filterName, bool bActive, const char *pFilterInfo = NULL );
+
+	// Get the directory this is currently in
+	void GetDirectory( char *buf, int bufSize );
+
+	// Get the last selected file name
+	void GetSelectedFileName( char *buf, int bufSize );
+
+	/*
+		messages sent:
+			"FileSelected"
+				"fullpath"	// specifies the fullpath of the file
+				"filterinfo"	// Returns the filter info associated with the active filter
+			"FileSelectionCancelled"
+	*/
+
+	static bool FileNameWildCardMatch( char const *pchFileName, char const *pchPattern );
+
+	// event handlers
+	bool EventOpen();
+	bool EventCancel();
+	bool EventClose();
+	bool EventFolderUp();
+	bool EventColumnSortingChanged( const CPanelPtr< IUIPanel > &pPanel, int nColumn );
+	bool EventSelectFile( const CPanelPtr< IUIPanel > &pPanel, uint32 unModifiers );
+	bool EventDoubleClickFile( const CPanelPtr< IUIPanel > &pPanel, uint32 unModifiers );
+	bool EventFullPathChanged();
+	bool EventFilterChanged();
+
+protected:
+	void Init();
+
+	void PopulateFileList();
+	void PopulateDriveList();
+
+	void OnOpen();
+
+	// TODO: needs message? hooked up to buttons/rows?
+	void OnSelectFolder();
+	void OnMatchStringSelected();
+
+	// moves the directory structure up
+	void MoveUpFolder();
+
+	// validates that the current path is valid
+	void ValidatePath();
+
+private:
+
+	// Does the specified extension match something in the filter list?
+	bool ExtensionMatchesFilter( const char *pExt );
+
+	// Choose the first non *.* filter in the filter list
+	void ChooseExtension( char *pExt, int nBufLen );
+
+	// Saves the file to the start dir context
+	void SaveFileToStartDirContext( const char *pFullPath );
+
+	// Posts a file selected message
+	void PostFileSelectedMessage( const char *pFileName );
+
+	// Posts a multiple file selected message
+	void PostMultiFileSelectedMessage();
+
+	void BuildFileList();
+	void FilterFileList();
+	void SortEntries();
+
+	bool PassesFilter( FileData_t *fd );
+	int  CountSubstringMatches();
+
+	void DeselectAllEntries();
+
+	CDropDown 		*m_pFullPathDropDown;
+	CPanel2D		*m_pFileList;	// TODO: custom spreadsheet style control?
+	
+	CTextEntry 		*m_pFileNameTextEntry;
+
+	CDropDown 		*m_pFileTypeCombo;
+	CButton 		*m_pOpenButton;
+	CButton 		*m_pCancelButton;
+	CButton 		*m_pFolderUpButton;
+	CLabel			*m_pFileTypeLabel;
+	CUtlVector<CPanel2D*> m_vecColumnHeaders;
+
+	KeyValues			*m_pContextKeyValues;
+
+	FileOpenDialogSorting_t m_nSorting;
+	bool m_bSortingReversed;
+
+	char m_szLastPath[1024];
+	unsigned short m_nStartDirContext;
+	FileOpenDialogType_t m_DialogType;
+	bool m_bFileSelected : 1;
+
+	CUtlVector< FileData_t > m_Files;
+	CUtlVector< FileData_t * > m_Filtered;
+
+	CUtlVector< CFileOpenDialogEntry* > m_vecSelectedEntries;
+
+	CUtlString			m_CurrentSubstringFilter;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: CFileOpenDialogEntry - single row in the dialog, represents one file
+//-----------------------------------------------------------------------------
+class CFileOpenDialogEntry : public CButton
+{
+	DECLARE_PANEL2D( CFileOpenDialogEntry, CButton );
+
+public:
+	CFileOpenDialogEntry( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CFileOpenDialogEntry();
+
+	void SetFileData( FileData_t *pFileData );
+	const FileData_t* GetFileData() const { return &m_FileData; }
+
+	virtual bool OnMouseButtonUp( const panorama::MouseData_t &code ) OVERRIDE;
+	virtual bool OnMouseButtonDoubleClick( const panorama::MouseData_t &code ) OVERRIDE;
+
+	bool OnScrolledIntoView( const CPanelPtr< IUIPanel > &panelPtr );
+
+private:
+	FileData_t m_FileData;
+
+	bool m_bCreatedControls;
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_FILEOPENDIALOG_H
diff --git a/public/panorama/controls/grid.h b/public/panorama/controls/grid.h
new file mode 100644
index 0000000..c5f0f63
--- /dev/null
+++ b/public/panorama/controls/grid.h
@@ -0,0 +1,189 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef GRID_H
+#define GRID_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "panorama/controls/label.h"
+#include "panorama/controls/mousescroll.h"
+
+namespace panorama
+{
+
+DECLARE_PANEL_EVENT0( ReadyPanelForDisplay )
+DECLARE_PANEL_EVENT0( PanelDoneWithDisplay )
+DECLARE_PANEL_EVENT0( GridMotionTimeout );
+DECLARE_PANEL_EVENT0( GridInFastMotion );
+DECLARE_PANEL_EVENT0( GridStoppingFastMotion );
+DECLARE_PANEL_EVENT0( GridPageLeft );
+DECLARE_PANEL_EVENT0( GridPageRight );
+DECLARE_PANEL_EVENT0( GridDirectionalMove );
+DECLARE_PANEL_EVENT1( ChildIndexSelected, int );
+
+//-----------------------------------------------------------------------------
+// Purpose: Button
+//-----------------------------------------------------------------------------
+class CGrid : public CPanel2D
+{
+	DECLARE_PANEL2D( CGrid, CPanel2D );
+
+public:
+	CGrid( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CGrid();
+
+	CPanel2D * AccessSelectedPanel() { return m_pFocusedChild.Get(); }
+
+	virtual void SetupJavascriptObjectTemplate() OVERRIDE;
+
+	// Scroll the grid so the focused panel is in the top left corner
+	void MoveFocusToTopLeft();
+
+	// Scroll the grid all the way to the left regardless of what's
+	// focused.
+	void ScrollPanelToLeftEdge();
+
+	// Trigger fast motion style temporarily, do this if you are directly setting focus ahead a bunch
+	void TriggerFastMotion();
+	void BumpFastMotionTimeout();
+
+	void SetHorizontalCount( int nCount ) { SetHorizontalAndVerticalCount( nCount, m_nVerticalCount ); }
+	void SetVerticalCount( int nCount ) { SetHorizontalAndVerticalCount( m_nHorizontalCount, nCount ); }
+	int GetHorizontalCount() const { return m_nHorizontalCount; }
+	int GetVerticalCount() const { return m_nVerticalCount; }
+
+	void SetHorizontalFocusLimit( int nCount ) { m_nHorizontalFocusLimit = nCount; InvalidateSizeAndPosition(); }
+	int GetHorizontalFocusLimit() const { return m_nHorizontalFocusLimit; }
+
+	float GetScrollProgress() const { return m_flScrollProgress; }
+
+	virtual bool OnMoveUp( int nRepeats );
+	virtual bool OnMoveDown( int nRepeats );
+	virtual bool OnMoveRight( int nRepeats );
+	virtual bool OnMoveLeft( int nRepeats );
+	virtual bool OnTabForward( int nRepeats );
+	virtual bool OnTabBackward( int nRepeats );
+	virtual bool OnMouseWheel( const panorama::MouseData_t &code );
+	virtual bool OnGamePadDown( const panorama::GamePadData_t &code );
+	virtual bool OnKeyDown( const KeyData_t &code );
+
+	virtual bool BRequiresContentClipLayer() OVERRIDE { return true; }
+
+	virtual void Paint();
+	virtual bool OnSetFocusToNextPanel( int nRepeats, EFocusMoveDirection moveType, bool bAllowWrap, float flTabIndexCurrent, float flXPosCurrent, float flYPosCurrent, float flXStart, float fYStart ) OVERRIDE
+	{
+		switch( moveType )
+		{
+		case k_ENextInTabOrder:
+			if ( OnTabForward( nRepeats ) )
+				return true;
+			break;
+		case k_ENextByXPosition:
+			if ( OnMoveRight( nRepeats ) )
+				return true;
+			break;
+		case k_EPrevInTabOrder:
+			if ( OnTabBackward( nRepeats ) )
+				return true;
+			break;
+		case k_EPrevByXPosition:
+			if ( OnMoveLeft( nRepeats ) )
+				return true;
+			break;
+		case k_ENextByYPosition:
+			if ( OnMoveDown( nRepeats ) )
+				return true;
+			break;
+		case k_EPrevByYPosition:
+			if ( OnMoveUp( nRepeats ) )
+				return true;
+			break;
+		default:
+			break;
+		}
+
+		return false;
+	}
+
+	void SetHorizontalAndVerticalCount( int nHorizontalCount, int nVerticalCount );
+
+	void SetIgnoreFastMotion( bool bValue ) { m_bIgnoreFastMotion = bValue; }
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
+#endif
+
+protected:
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+	virtual void OnBeforeChildrenChanged() { m_bForceRelayout = true;  }
+
+	virtual void OnChildStylesChanged() OVERRIDE { m_bVecVisibleDirty = true; }
+	virtual void OnAfterChildrenChanged() OVERRIDE { m_bVecVisibleDirty = true; }
+private:
+
+	void UpdateVecVisible();
+	int GetVisibleChildCount();
+	CPanel2D *GetVisibleChild( int iVisibleIndex );
+
+	// event handlers
+	bool EventInputFocusSet( const CPanelPtr< IUIPanel > &ptrPanel );
+	bool EventInputFocusLost( const CPanelPtr< IUIPanel > &ptrPanel );
+	bool MotionTimeout( const CPanelPtr< IUIPanel > &ptrPanel );
+	bool OnMouseScroll( const CPanelPtr< IUIPanel > &ptrPanel, int cRepeat );
+	void LayoutMouseScrollRegions( float flFinalWidth, float flFinalHeight );
+	bool EventWindowCursorShown( IUIWindow *pWindow );
+	bool EventWindowCursorHidden( IUIWindow *pWindow );
+
+	void RegisterForCursorChanges();
+	void UnregisterForCursorChanges();
+
+	int GetFocusedChildVisibleIndex();
+	void UpdateChildPositions( bool bForceTopLeft = false );
+
+	bool m_bHadFocus;
+
+	CPanelPtr< CPanel2D > m_pFocusedChild;
+	CUtlVector< CPanelPtr<CPanel2D> > m_vecPanelsReadyForDisplay;
+
+	int m_nScrollOffset;
+
+	float m_flChildWidth;
+	float m_flChildHeight;
+	float m_flScaleOffset;
+
+	float m_flScrollProgress;
+
+	int m_nHorizontalCount;
+	int m_nVerticalCount;
+	
+	// Override how far right you can move before all items must shift, should be smaller than m_nHorizontalCount
+	int m_nHorizontalFocusLimit;
+
+	double m_flLastMouseWheel;
+	bool m_bForceRelayout;
+
+	bool m_bIgnoreFastMotion;
+	double m_flStartedMotion;
+	double m_flLastMotion;
+	uint64 m_ulMotionSinceStart;
+	bool m_bFastMotionStarted;
+	bool m_bVecVisibleDirty;
+
+	CUtlVector< CPanel2D * > m_vecVisibleChildren;
+	
+	panorama::CMouseScrollRegion *m_pLeftMouseScrollRegion;
+	panorama::CMouseScrollRegion *m_pRightMouseScrollRegion;
+
+};
+
+
+} // namespace panorama
+
+#endif // GRID_H
diff --git a/public/panorama/controls/html.h b/public/panorama/controls/html.h
new file mode 100644
index 0000000..b1b9902
--- /dev/null
+++ b/public/panorama/controls/html.h
@@ -0,0 +1,768 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_HTML_H
+#define PANORAMA_HTML_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "tier1/utlmap.h"
+#include "tier1/utlstring.h"
+#include "../uievent.h"
+#include "mathlib/beziercurve.h"
+#include "../textinput/textinput.h"
+
+#if !defined( SOURCE2_PANORAMA ) && !defined( PANORAMA_PUBLIC_STEAM_SDK )
+#include "html/ihtmlchrome.h"
+#include "tier1/shared_memory.h"
+#endif
+
+class CTexturePanel;
+namespace panorama
+{
+class CTextTooltip;
+class CHTML;
+class CFileOpenDialog;
+
+struct HtmlFormHasFocus_t
+{
+	HtmlFormHasFocus_t() :
+		m_bInput( false ),
+		m_bInputHasMultiplePeers( false ),
+		m_bUserInputThisPage( false ),
+		m_bFocusedElementChanged( true )
+	{
+	}
+	void Reset()
+	{
+		m_bInput = false;
+		m_bUserInputThisPage = false;
+		m_bInputHasMultiplePeers = false;
+		m_bFocusedElementChanged = true;
+	}
+
+	bool operator==(const HtmlFormHasFocus_t &rhs) const
+	{
+		return rhs.m_bInput == m_bInput && 
+			rhs.m_sName == m_sName &&
+			rhs.m_sSearchLabel == m_sSearchLabel &&
+			rhs.m_sInputType == m_sInputType;
+	}
+	bool			m_bInput;
+	CUtlString		m_sName;
+	CUtlString		m_sSearchLabel;
+	bool			m_bInputHasMultiplePeers;
+	bool			m_bUserInputThisPage;
+	CUtlString		m_sInputType;
+	bool			m_bFocusedElementChanged;
+};
+
+DECLARE_PANEL_EVENT2( HTMLURLChanged, const char *, const char * )
+DECLARE_PANEL_EVENT1( HTMLLoadPage, const char * )
+DECLARE_PANEL_EVENT2( HTMLFinishRequest, const char *, const char * )
+DECLARE_PANEL_EVENT1( HTMLTitle, const char * )
+DECLARE_PANEL_EVENT1( HTMLStatusText, const char * )
+DECLARE_PANEL_EVENT2( HTMLJSAlert, const char *, bool * )
+DECLARE_PANEL_EVENT2( HTMLJSConfirm, const char *, bool * )
+DECLARE_PANEL_EVENT2( HMTLLinkAtPosition, const char *, bool )
+DECLARE_PANEL_EVENT4( HMTLThumbNailImage, int, CUtlBuffer *, uint32, uint32  )
+DECLARE_PANEL_EVENT1( HTMLOpenLinkInNewTab, const char * )
+DECLARE_PANEL_EVENT2( HTMLOpenPopupTab,  CHTML *, const char * )
+DECLARE_PANEL_EVENT2( HTMLBackForwardState, bool, bool )
+DECLARE_PANEL_EVENT2( HTMLUpdatePageSize, int, int )
+DECLARE_PANEL_EVENT5( HTMLSecurityStatus, const char *, bool, bool, bool, const char * )
+DECLARE_PANEL_EVENT1( HTMLFullScreen, bool )
+DECLARE_PANEL_EVENT2( HTMLStartMousePanning, int, int )
+DECLARE_PANEL_EVENT0( HTMLStopMousePanning )
+DECLARE_PANEL_EVENT0( HTMLCloseWindow )
+DECLARE_PANEL_EVENT2( HTMLFormHasFocus, HtmlFormHasFocus_t, const char * /* URL */ )
+DECLARE_PANEL_EVENT2( HTMLScreenShotTaken, const char *, const char * )
+DECLARE_PANEL_EVENT1( HTMLFocusedNodeValue, const char * )
+DECLARE_PANEL_EVENT0( HTMLSteamRightPadMoving );
+DECLARE_PANEL_EVENT2( HTMLStartRequest, const char *, bool * );
+
+class CImagePanel;
+
+enum CursorCode
+{
+	eCursorNone,
+	eCursorArrow
+};
+
+class IUIDoubleBufferedTexture;
+class CTransform3D;
+extern const int k_nExtraScrollRoom; // max number of padding pixels to use if needed
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+class CHTML : public CPanel2D, public ITextInputControl
+#if !defined( SOURCE2_PANORAMA ) && !defined( PANORAMA_PUBLIC_STEAM_SDK )
+	, public IHTMLResponses
+#endif
+{
+	DECLARE_PANEL2D( CHTML, CPanel2D );
+
+public:
+	CHTML( CPanel2D *parent, const char * pchPanelID,  bool bPopup = false );
+	virtual ~CHTML();
+	void Shutdown();
+
+	// panel2d overrides
+	virtual void Paint();
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+	virtual void OnStylesChanged();
+	virtual bool BRequiresContentClipLayer() OVERRIDE { return true; } // BUGBUG Alfred - fix ::Paint to scale u/v offsets rather than requiring a clipping
+
+	// simple browser management
+	void OpenURL(const char *);
+	void PostURL( const char *pchURL, const char *pchPostData );
+	void AddHeader( const char *pchHeader, const char *pchValue );
+	void StopLoading();
+	void Refresh();
+	void GoBack();
+	void GoForward();
+	bool BCanGoBack();
+	bool BCanGoForward();
+	
+	// kb/mouse management
+	virtual bool OnKeyDown( const KeyData_t &code ) OVERRIDE;
+	virtual bool OnKeyUp( const KeyData_t & code ) OVERRIDE;
+	virtual bool OnKeyTyped( const KeyData_t &unichar ) OVERRIDE;
+	virtual bool OnGamePadDown( const GamePadData_t &code ) OVERRIDE;
+	virtual bool OnGamePadUp( const GamePadData_t &code ) OVERRIDE;
+	virtual bool OnGamePadAnalog( const GamePadData_t &code ) OVERRIDE;
+	virtual bool OnMouseButtonDown( const MouseData_t &code ) OVERRIDE;
+	virtual bool OnMouseButtonUp( const MouseData_t &code ) OVERRIDE;
+	virtual bool OnMouseButtonDoubleClick( const MouseData_t &code ) OVERRIDE;
+	virtual bool OnMouseWheel( const MouseData_t &code ) OVERRIDE;
+	virtual void OnMouseMove( float flMouseX, float flMouseY ) OVERRIDE;
+
+	virtual void SetupJavascriptObjectTemplate() OVERRIDE;
+
+	// run input event processing for something that may not be a real input event, so don't bubble to parents, etc.
+	bool OnGamePadDownImpl( const GamePadData_t &code, bool *out_pbOptionalResult = nullptr );
+	bool OnGamePadAnalogImpl( const GamePadData_t &code, bool *out_pbOptionalResult = nullptr );
+	
+	bool ProcessAnalogScroll( float fValueX, float fValueY, double fTimeDelta, float fDeadzoneValue );
+	bool ProcessAnalogZoom( float fValueX, float fValueY, double fTimeDelta, float fDeadzoneValue );
+	void ProcessRawScroll( bool bFingerDown );
+	void ProcessRawZoom( float fValueRaw );
+
+	// browser helpers
+	void Copy();
+	void Paste();
+	void RequestLinkUnderGamepad() { RequestLinkAtPosition( GetActualLayoutWidth()/2 - GetHScrollOffset(), GetActualLayoutHeight()/2 - GetVScrollOffset() ); }
+	void RequestLinkUnderMouse() { RequestLinkAtPosition( m_flCursorX - GetHScrollOffset(), m_flCursorY - GetVScrollOffset() ); }
+	void ZoomToElementUnderPanelCenter();
+	void ZoomToElementUnderMouse();
+	const char *PchLastLinkAtPosition() { return m_LinkAtPos.m_sURL; }
+	void RunJavascript( const char *pchScript );
+	void ViewSource();
+	void SetHorizontalScroll( int scroll );
+	void SetVerticalScroll( int scroll );
+	void OnHTMLCursorMove( float flMouseX, float flMouseY );
+
+	// finding text on the page
+	void Find( const char *pchSubStr );
+	void StopFind();
+	void FindNext();
+	void FindPrevious();
+
+	void SetFileDialogChoice( const char *pchFileName ); // callback if cef wanted us to pick a file
+
+	bool BAcceptMouseInput(); // returns true if the control is listening to mouse input right now, false if gamepad input mode is on
+	virtual bool BRequiresFocus() OVERRIDE { return true; }
+
+	bool BIgnoreMouseBackForwardButtons() { return m_bIgnoreMouseBackForwardButtons; }
+	void SetIgnoreMouseBackForwardButtons( bool bIgnore ) { m_bIgnoreMouseBackForwardButtons = bIgnore; }
+
+	const char *PchCurrentURL() { return m_sCurrentURL; } // the current URL the browser has loaded
+	const char *PchCurrentPageTitle() { return m_sHTMLTitle; } // the title of the currently loaded page
+
+	void SaveCurrentPageToJPEG( const char *pchFileName, int nWide, int nTall ); // save this current page to a jpeg
+
+	// results for JS alert popups
+	void DismissJSDialog( bool bRetVal );
+
+	static uint32 GetAndResetPaintCounter();
+
+	void ReleaseTextureMemory( bool bSuppressTextureLoads = false );
+	void RefreshTextureMemory();
+
+	void CaptureThumbNailImage( CPanel2D *pEventTarget, int iUserData );
+	void IncrementPageScale( float flScaleIncrement, bool bZoomFromOrigin = false );
+	void ExitFullScreen();
+	void ExecuteJavaScript( const char *pchScript );
+
+	// SSL/security state for the loaded html page
+	bool BIsSecure() const { return m_bIsSecure; }
+	bool BIsCertError() const { return m_bIsCertError; }
+	bool BIsEVCert() const { return m_bIsEVCert; }
+	const char *PchCertName() const { return m_sCertName; }
+
+	// if true don't allow the page to scroll beyond the page edges
+	void SetDontAllowOverScroll( bool bState );
+	void SetEmbeddedMode( bool bState );
+
+	void ZoomPageToFocusedElement( int nLeftOffset, int nTopOffset );
+
+	// ITextInputControl helpers
+	virtual int32 GetCursorOffset() const { return 0; }
+	virtual  uint GetCharCount() const { return 0; }
+
+	virtual const char *PchGetText() const { return ""; }
+	virtual const wchar_t *PwchGetText() const { return L""; }
+
+	virtual void InsertCharacterAtCursor( const wchar_t &unichar );
+	virtual void InsertCharactersAtCursor( const wchar_t *pwch, size_t cwch ) 
+	{
+		for ( uint i = 0; i < cwch; i++ )
+			InsertCharacterAtCursor( pwch[i] ); 
+	}
+	bool BSupportsImmediateTextReturn() { return false; }
+	void RequestControlString() { RequestFocusedNodeValue(); }
+
+	virtual CPanel2D *GetAssociatedPanel() { return this; }
+
+	void PauseFlashVideoIfVisible();
+
+	void ResetScrollbarsAndClearOverflow();
+
+	void SetPopupChild(CHTML *pChild) { m_pPopupChild = pChild; }
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const char *pchName ) OVERRIDE;
+	static void ValidateStatics( CValidator &validator, const char *pchName );
+#endif
+
+	class CHTMLVerticalScrollBar : public CScrollBar
+	{
+		DECLARE_PANEL2D( CHTMLVerticalScrollBar, CScrollBar );
+
+	public:
+		CHTMLVerticalScrollBar( CPanel2D *parent, const char * pchPanelID ) : CScrollBar( parent, pchPanelID )
+		{
+			m_pScrollThumb->AddClass( "VerticalScrollThumb" );
+		}
+
+		void ScrollToMousePos()
+		{
+			float flHeight = GetActualLayoutHeight();
+			if ( flHeight > 0.00001f )
+			{
+				if ( m_bMouseWentDownOnThumb )
+				{
+					float flPercentDiff = (m_flMouseY - m_flMouseStartY) / flHeight;
+					float flPositionOffset = flPercentDiff * GetRangeSize();
+					float flPosition = m_flScrollStartPosition + flPositionOffset;
+					SetScrollWindowPosition( clamp( flPosition, 0.0f, GetRangeSize() - GetScrollWindowSize() ), true );
+				}
+				else
+				{
+					float flPercent = m_flMouseY / flHeight;
+					float flPos = GetRangeSize() * flPercent;
+					SetScrollWindowPosition( clamp( flPos, 0.0f, GetRangeSize() - GetScrollWindowSize() ), true );
+				}
+			}
+		}
+
+
+		virtual ~CHTMLVerticalScrollBar() {}
+
+	protected:
+		virtual void UpdateLayout( bool bImmediateMove )
+		{
+			CUILength zero;
+			zero.SetLength( 0.0f );
+
+			if ( GetRangeSize() < 0.001f )
+				return;
+
+			CUILength length;
+
+			float flXPosPercent = (GetScrollWindowPosition() - GetRangeMin()) / GetRangeSize();
+			length.SetPercent( flXPosPercent * 100.0f );
+			if ( bImmediateMove )
+				m_pScrollThumb->SetPositionWithoutTransition( zero, length, zero );
+			else
+				m_pScrollThumb->SetPosition( zero, length, zero );
+
+			float flWidthPercent = GetScrollWindowSize() / GetRangeSize();
+
+			length.SetPercent( flWidthPercent*100.0f );
+			m_pScrollThumb->AccessStyleDirty()->SetHeight( length );
+			length.SetPercent( 100.0f );
+			m_pScrollThumb->AccessStyleDirty()->SetWidth( length );
+
+			m_bLastMoveImmediate = bImmediateMove;
+		}
+	};
+
+	class CHTMLHorizontalScrollBar : public CScrollBar
+	{
+		DECLARE_PANEL2D( CHTMLHorizontalScrollBar, CScrollBar );
+
+	public:
+		CHTMLHorizontalScrollBar( CPanel2D *parent, const char * pchPanelID ) : CScrollBar( parent, pchPanelID )
+		{
+			m_pScrollThumb->AddClass( "HorizontalScrollThumb" );
+		}
+
+		void ScrollToMousePos()
+		{
+			float flWidth = GetActualLayoutWidth();
+			if ( flWidth > 0.00001f )
+			{
+				if ( m_bMouseWentDownOnThumb )
+				{
+					float flPercentDiff = (m_flMouseX - m_flMouseStartX) / flWidth;
+					float flPositionOffset = flPercentDiff * GetRangeSize();
+					float flPosition = m_flScrollStartPosition + flPositionOffset;
+					SetScrollWindowPosition( clamp( flPosition, 0.0f, GetRangeSize() - GetScrollWindowSize() ), true );
+				}
+				else
+				{
+					float flPercent = m_flMouseX / flWidth;
+					float flPos = GetRangeSize() * flPercent;
+					SetScrollWindowPosition( clamp( flPos, 0.0f, GetRangeSize() - GetScrollWindowSize() ), true );
+				}
+			}
+		}
+
+
+		virtual ~CHTMLHorizontalScrollBar() {}
+
+	protected:
+		virtual void UpdateLayout( bool bImmediateMove )
+		{
+			CUILength zero;
+			zero.SetLength( 0.0f );
+
+			if ( GetRangeSize() < 0.001f )
+				return;
+
+			CUILength length;
+
+			float flXPosPercent = (GetScrollWindowPosition() - GetRangeMin()) / GetRangeSize();
+			length.SetPercent( flXPosPercent * 100.0f );
+			if ( bImmediateMove )
+				m_pScrollThumb->SetPositionWithoutTransition( length, zero, zero );
+			else
+				m_pScrollThumb->SetPosition( length, zero, zero );
+
+			float flWidthPercent = GetScrollWindowSize() / GetRangeSize();
+
+			length.SetPercent( flWidthPercent*100.0f );
+			m_pScrollThumb->AccessStyleDirty()->SetWidth( length );
+			length.SetPercent( 100.0f );
+			m_pScrollThumb->AccessStyleDirty()->SetHeight( length );
+			m_bLastMoveImmediate = bImmediateMove;
+		}
+	};
+
+	enum EHTMLScrollDirection
+	{
+		kHTMLScrollDirection_Up,
+		kHTMLScrollDirection_Down,
+		kHTMLScrollDirection_Left,
+		kHTMLScrollDirection_Right
+	};
+
+	bool BCanScrollInDirection( EHTMLScrollDirection eDirection ) const;
+
+	static float GetScrollDeadzoneScale() { return s_fScrollDeadzoneScale; }
+
+protected:
+	// functions you can override to specialize html behavior
+	virtual void OnURLChanged( const char *url, const char *pchPostData, bool bIsRedirect );
+	virtual void OnFinishRequest(const char *url, const char *pageTitle);
+	virtual void OnPageLoaded( const char *url, const char *pageTitle, const CUtlMap < CUtlString, CUtlString > &headers );
+	virtual bool OnStartRequestInternal( const char *url, const char *target, const char *pchPostData, bool bIsRedirect );
+	virtual void ShowPopup();
+	virtual void HidePopup();
+	virtual bool OnOpenNewTab( const char *pchURL, bool bForeground );
+	virtual bool OnPopupHTMLWindow( const char *pchURL, int x, int y, int wide, int tall );
+	virtual void SetHTMLTitle( const char *pchTitle );
+	virtual void OnLoadingResource( const char *pchURL );
+	virtual void OnSetStatusText(const char *text);
+	virtual void OnSetCursor( CursorCode cursor );
+	virtual void OnFileLoadDialog( const char *pchTitle, const char *pchInitialFile );
+	virtual void OnShowToolTip( const char *pchText );
+	virtual void OnUpdateToolTip( const char *pchText );
+	virtual void OnHideToolTip();
+	virtual void OnSearchResults( int iActiveMatch, int nResults );
+
+	friend class ::CTexturePanel;
+	IUIDoubleBufferedTexture *m_pDoubleBufferedTexture;
+	IUIDoubleBufferedTexture *m_pDoubleBufferedTexturePending;
+	IUIDoubleBufferedTexture *m_pDoubleBufferedTextureComboBox;
+	int32 m_nTextureSerial; // serial number of the last texture we uploaded
+
+	void RequestFocusedNodeValue();
+	// if true then our html control overrides scrolling and scrollbars, if false we 
+	// let the web control scroll itself
+	void SetManualHTMLScroll( bool bControlScroll ) { m_bControlPageScrolling = bControlScroll;  }
+
+private:
+	typedef void (CHTML::* ScrollFunc_t)( float, bool );
+	bool ProcessAnalogScrollAxis( float fValue, float fDeadzoneValue, double fTimeDelta, ScrollFunc_t ScrollFunc );
+
+	// we used to create the virtual mouse in our constructor, but now we don't know enough information at
+	// construction time to know whether we want one (ie., if we're wrapped by CHTMLSimpleNavigationWrapper
+	// we disable touchpad navigation). Instead we just try to lazy-create one at first use.
+	void LazyCreateVirtualMouseIfNecessary();
+
+	// getters/setters for html cef object
+	void SetHTMLFocus();
+	void KillHTMLFocus();
+	int HorizontalScroll();
+	int VerticalScroll();
+	bool IsHorizontalScrollBarVisible();
+	bool IsVeritcalScrollBarVisible();
+	void RequestLinkAtPosition( int x, int y );
+	void GetCookiesForURL( const char *pchURL );
+	void UpdatePanoramaScrollBars();
+	bool BHandleKeyPressPageScroll() const;
+
+#if defined( SOURCE2_PANORAMA ) || defined( PANORAMA_PUBLIC_STEAM_SDK )
+	STEAM_CALLBACK( CHTML, OnLinkAtPositionResponse, HTML_LinkAtPosition_t, m_LinkAtPosRespose );
+
+	STEAM_CALLBACK( CHTML, OnHTMLNeedsPaint, HTML_NeedsPaint_t, m_HTML_NeedsPaint );
+	STEAM_CALLBACK( CHTML, OnHTMLStartRequest, HTML_StartRequest_t, m_HTML_StartRequest );
+	STEAM_CALLBACK( CHTML, OnHTMLCloseBrowser, HTML_CloseBrowser_t, m_HTML_CloseBrowser );
+	STEAM_CALLBACK( CHTML, OnHTMLURLChanged, HTML_URLChanged_t, m_HTML_URLChanged );
+	STEAM_CALLBACK( CHTML, OnHTMLFinishedRequest, HTML_FinishedRequest_t, m_HTML_FinishedRequest );
+	STEAM_CALLBACK( CHTML, OnHTMLOpenLinkInNewTab, HTML_OpenLinkInNewTab_t, m_HTML_OpenLinkInNewTab );
+	STEAM_CALLBACK( CHTML, OnHTMLChangedTitle, HTML_ChangedTitle_t, m_HTML_ChangedTitle );
+	STEAM_CALLBACK( CHTML, OnHTMLSearchResults, HTML_SearchResults_t, m_HTML_SearchResults );
+	STEAM_CALLBACK( CHTML, OnHTMLCanGoBackAndForward, HTML_CanGoBackAndForward_t, m_HTML_CanGoBackAndForward );
+	STEAM_CALLBACK( CHTML, OnHTMLHorizontalScroll, HTML_HorizontalScroll_t, m_HTML_HorizontalScroll );
+	STEAM_CALLBACK( CHTML, OnHTMLVerticalScroll, HTML_VerticalScroll_t, m_HTML_VerticalScroll );
+	STEAM_CALLBACK( CHTML, OnHTMLJSAlert, HTML_JSAlert_t, m_HTML_JSAlert );
+	STEAM_CALLBACK( CHTML, OnHTMLJSConfirm, HTML_JSConfirm_t, m_HTML_JSConfirm );
+	STEAM_CALLBACK( CHTML, OnHTMLFileOpenDialog, HTML_FileOpenDialog_t, m_HTML_FileOpenDialog );
+	STEAM_CALLBACK( CHTML, OnHTMLNewWindow, HTML_NewWindow_t, m_HTML_NewWindow );
+	STEAM_CALLBACK( CHTML, OnHTMLSetCursor, HTML_SetCursor_t, m_HTML_SetCursor );
+	STEAM_CALLBACK( CHTML, OnHTMLStatusText, HTML_StatusText_t, m_HTML_StatusText );
+	STEAM_CALLBACK( CHTML, OnHTMLShowToolTip, HTML_ShowToolTip_t, m_HTML_ShowToolTip );
+	STEAM_CALLBACK( CHTML, OnHTMLUpdateToolTip, HTML_UpdateToolTip_t, m_HTML_UpdateToolTip );
+	STEAM_CALLBACK( CHTML, OnHTMLHideToolTip, HTML_HideToolTip_t, m_HTML_HideToolTip );
+#else
+	// message handlers for ipc thread
+	void BrowserSetIndex( int idx ) { m_iBrowser = idx; SendPendingHTMLMessages(); }
+	int  BrowserGetIndex() { return m_iBrowser; }
+	void BrowserReady( const CMsgBrowserReady *pCmd );
+	void BrowserSetSharedPaintBuffers( const CMsgSetSharedPaintBuffers *pCmd );
+	void BrowserNeedsPaint( const CMsgNeedsPaint *pCmd );
+	void BrowserStartRequest( const CMsgStartRequest *pCmd );
+	void BrowserURLChanged( const CMsgURLChanged *pCmd );
+	void BrowserLoadedRequest( const CMsgLoadedRequest *pCmd );
+	void BrowserFinishedRequest(const CMsgFinishedRequest *pCmd);
+	void BrowserPageSecurity( const CMsgPageSecurity *pCmd );
+	void BrowserShowPopup( const CMsgShowPopup *pCmd );
+	void BrowserHidePopup( const CMsgHidePopup *pCmd );
+	void BrowserOpenNewTab( const CMsgOpenNewTab *pCmd );
+	IHTMLResponses *BrowserPopupHTMLWindow( const CMsgPopupHTMLWindow *pCmd );
+	void BrowserSetHTMLTitle( const CMsgSetHTMLTitle *pCmd );
+	void BrowserLoadingResource( const CMsgLoadingResource *pCmd );
+	void BrowserStatusText( const CMsgStatusText *pCmd );
+	void BrowserSetCursor( const CMsgSetCursor *pCmd );
+	void BrowserFileLoadDialog( const CMsgFileLoadDialog *pCmd );
+	void BrowserShowToolTip( const CMsgShowToolTip *pCmd );
+	void BrowserUpdateToolTip( const CMsgUpdateToolTip *pCmd );
+	void BrowserHideToolTip( const CMsgHideToolTip *pCmd );
+	void BrowserSearchResults( const CMsgSearchResults *pCmd );
+	void BrowserClose( const CMsgClose *pCmd );
+	void BrowserHorizontalScrollBarSizeResponse( const CMsgHorizontalScrollBarSizeResponse *pCmd );
+	void BrowserVerticalScrollBarSizeResponse( const CMsgVerticalScrollBarSizeResponse *pCmd );
+	void BrowserGetZoomResponse( const CMsgGetZoomResponse *pCmd ) {}
+	void BrowserLinkAtPositionResponse( const CMsgLinkAtPositionResponse *pCmd );
+	void BrowserZoomToElementAtPositionResponse( const CMsgZoomToElementAtPositionResponse *pCmd );
+	void BrowserJSAlert( const CMsgJSAlert *pCmd );
+	void BrowserJSConfirm( const CMsgJSConfirm *pCmd );
+	void BrowserCanGoBackandForward( const CMsgCanGoBackAndForward *pCmd );
+	void BrowserOpenSteamURL( const CMsgOpenSteamURL *pCmd );
+	void BrowserSizePopup( const CMsgSizePopup *pCmd );
+	void BrowserScalePageToValueResponse( const CMsgScalePageToValueResponse *pCmd );
+	void BrowserRequestFullScreen( const CMsgRequestFullScreen *pCmd );
+	void BrowserExitFullScreen( const CMsgExitFullScreen *pCmd );
+	void BrowserGetCookiesForURLResponse( const CMsgGetCookiesForURLResponse *pCmd );
+	void BrowserNodeGotFocus( const CMsgNodeHasFocus *pCmd );
+	void BrowserSavePageToJPEGResponse( const CMsgSavePageToJPEGResponse *pCmd );
+	void BrowserFocusedNodeValueResponse( const CMsgFocusedNodeTextResponse *pCmd );
+	void BrowserComboNeedsPaint(const CMsgComboNeedsPaint *pCmd);
+	bool BSupportsOffMainThreadPaints();
+	void ThreadNotifyPendingPaints();
+#endif
+
+	// helpers to control browser side, pos and textures
+	void SetBrowserSize( int wide, int tall );
+	void SendPendingHTMLMessages();
+
+	// helpers to move the html page around inside the control
+	void ScrollPageUp( float flScrollValue, bool bApplyBezier );
+	void ScrollPageDown( float flScrollValue, bool bApplyBezier );
+	void ScrollPageLeft( float flScrollValue, bool bApplyBezier );
+	void ScrollPageRight( float flScrollValue, bool bApplyBezier );
+
+	// Overrides for scroll bar to call back to us rather than normal panel2d call
+	virtual void ScrollToXPercent( float flXPercent );
+	virtual void ScrollToYPercent( float flXPercent );
+
+	// event handlers
+	bool OnGamepadInput();
+	bool OnPropertyTransitionEnd( const CPanelPtr< IUIPanel > &pPanel, CStyleSymbol prop );
+	bool OnSetBrowserSize( const CPanelPtr< IUIPanel > &pPanel, int nWide, int nTall );
+	bool OnHTMLFormFocusPending( const CPanelPtr< IUIPanel > &pPanel );
+	bool OnInputFocusSet( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel );
+	bool OnInputFocusLost( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel );
+	bool OnHTMLScreenShotCaptured( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel, int nThumbNailWidth, int nThumbNailHeight  );
+	bool OnHTMLCommitZoom( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel, float flZoom );
+	bool OnHTMLRequestRepaint( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel );
+
+#if defined( SOURCE2_PANORAMA ) || defined( PANORAMA_PUBLIC_STEAM_SDK )
+	bool OnFileOpenDialogFilesSelected( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel, const char *pszFiles );
+#endif
+
+	// moving the html texture around
+	void ResizeBrowserTextureIfNeeded();
+	int AdjustPageScrollForTextureOffset( int &nTargetValue, const int nCurScroll, const int nMaxScroll, float &flOffsetTextureScroll, const float flMaxTextureScroll );
+
+	int GetHScrollOffset() 
+	{ 
+		return m_ScrollLeft.m_flOffsetTextureScroll;
+	}
+
+	int GetVScrollOffset() 
+	{ 
+		return m_ScrollUp.m_flOffsetTextureScroll;
+	}
+
+	void ClampTextureScroll( bool bAllowScrollBorder = true );
+
+	bool m_bInitialized; // used to prevent double shutdown
+	bool m_bReady; // When we are ready to load a url
+	CTexturePanel *m_pTexurePanel;
+
+	int m_nWindowWide, m_nWindowTall; // how big the html texture should be
+	int m_nTextureWide, m_nTextureTall;
+
+	// find in page state
+	bool m_bInFind;
+	CUtlString m_sLastSearchString;
+
+	CUtlString m_sURLToLoad; // url to load once the browser is created
+	CUtlString m_sURLPostData; // post data for url to load
+
+	CUtlString m_sCurrentURL; // the current url we have loaded
+	CUtlString m_sHTMLTitle; // the title of the page we are on
+
+	int m_iBrowser; // our browser handle
+
+	float m_flZoom; // what zoom level we are at
+	bool m_bLastKeyFocus; // tracking for when key focus changes in style application
+
+	struct ScrollControl_t
+	{
+		ScrollControl_t()
+		{
+			Reset();
+		}
+
+		void Reset()
+		{
+			m_flOffsetTextureScroll = 0.0f;
+			m_bScrollingUp = false;
+			m_flLastScrollTime = 0.0f;
+		}
+
+		float m_flOffsetTextureScroll; // amount the html texture is scrolled around the panel itself
+		bool m_bScrollingUp; // we are scrolling up (or left) on the page last?
+		double m_flLastScrollTime; // when did we scroll in this direction last, used for accel curve
+	};
+
+	ScrollControl_t m_ScrollUp;
+	ScrollControl_t m_ScrollLeft;
+
+	struct ScrollData_t
+	{
+		ScrollData_t() 
+		{
+			m_bVisible = false;
+			m_nMaxScroll = m_nScroll = m_nPageSize = m_nWebScroll = 0;
+		}
+
+		bool operator==( const ScrollData_t &rhs ) const
+		{
+			return rhs.m_bVisible == m_bVisible &&
+				rhs.m_nScroll == m_nScroll &&
+				rhs.m_nPageSize == m_nPageSize &&
+				rhs.m_nMaxScroll == m_nMaxScroll;
+		}
+
+		bool operator!=( const ScrollData_t &rhs ) const
+		{
+			return !operator==(rhs);
+		}
+
+		bool m_bVisible; // is the scroll bar visible
+		int m_nMaxScroll; // most amount of pixels we can scroll
+		int m_nPageSize; // the underlying size of the page itself in pixels
+		int m_nScroll; // currently scrolled amount of pixels
+		int m_nWebScroll; // last scrolled return value from cef, not updated locally
+	};
+	bool ScrollHelper( ScrollControl_t &scrollControl, float flScrollDelta, int iMaxScrollOffset, ScrollData_t &scrollBar, float &flScrollHTMLAmount, bool bApplyBezier ); // shared code when scrolling around the page
+	bool SetupScrollBar( const ScrollData_t & scrollData, bool bHorizontal, float flContentSize, float flMaxSize );
+	CScrollBar *MakeScrollBar( bool bHorizontal);
+
+	ScrollData_t m_scrollHorizontal; // details of horizontal scroll bar
+	ScrollData_t m_scrollVertical; // details of vertical scroll bar
+	CCubicBezierCurve< Vector2D > m_ScrollBezier; // the curve to scale scroll accel by
+
+	struct LinkAtPos_t
+	{
+		LinkAtPos_t() { m_bLiveLink = false; }
+		CUtlString m_sURL;
+		bool m_bLiveLink;
+		bool m_bInput;
+	};
+	LinkAtPos_t m_LinkAtPos; // cache for link at pos requests, because the request is async
+
+	// last position we saw the mouse at
+	float m_flCursorX;
+	float m_flCursorY;
+
+	double m_flGamePadInputTime; // last time we saw input from the gamepad
+
+	bool m_bPopupVisible; // true if a popup menu is visible on the client
+	bool m_bCanGoBack;
+	bool m_bCanGoForward;
+	bool m_bIgnoreMouseBackForwardButtons;
+
+	int m_nHTMLPageWide; // last size we told CEF the page should be 
+	int m_nHTMLPageTall;
+
+	CHTMLVerticalScrollBar *m_pVerticalScrollBar; // our own copy of the scroll bars that we control manually
+	CHTMLHorizontalScrollBar *m_pHorizontalScrollBar;
+	float m_flLastVeritcalScrollPos;
+	float m_flLastHorizontalScrollPos;
+
+	static uint32 sm_PaintCount;
+	uint32 m_PageLoadCount; // the number of posturl calls we have made
+#if !defined( SOURCE2_PANORAMA ) && !defined( PANORAMA_PUBLIC_STEAM_SDK )
+	CUtlVector<HTMLCommandBuffer_t *> m_vecPendingMessages;
+#endif
+	bool m_bSuppressTextureLoads;
+
+	bool m_bCaptureThumbNailThisFrame;
+	CPanel2D *m_pCaptureEventTarget;
+	int m_nCaptureUserData;
+
+	bool m_bCommenceZoomOperationOnTextureUpload; // when the next texture upload is ready, should we apply scale/offset transforms we have saved above
+	float m_flHorizScrollOffset; // the offset between page scroll and texture scroll we had at the start of a zoom
+	float m_flVertScrollOffset; // the offset between page scroll and texture scroll we had at the start of a zoom
+	bool m_bFullScreen; // are we in fullscreen right now?
+	bool m_bConfigureYouTubeHTML5OptIn; // are we doing the forcefully opt into youtube html5 beta path
+	bool m_bMousePanningActive; // true if the mouse is in panning mode
+	Vector2D m_vecMousePanningPos; // the x,y pos of the mouse over the panel when middle panning started
+	CImagePanel *m_pMousePanningImage; // the image to show when panning
+	CCubicBezierCurve< Vector2D > m_MousePanBezier; // the curve to scale panning accel by
+	bool m_bIsSecure; // is this page ssl secure?
+	bool m_bIsCertError; // did we have a cert error when loading? 
+	bool m_bIsEVCert; // is it an EV cert?
+	CUtlString m_sCertName; // who was the cert issued to?
+	bool m_bEmbedded; // if true we are embedded instance, just show html pages and simple scrolling, not complex interactions
+	bool m_bAllowOverScroll; // if true allow scrolling the edge of the texture beyond the edge of the screen (i.e so you can hover the recticle at any point)
+	bool m_bLastScrollbarSetupAllowedOverScroll;
+	float m_flMouseLastX;
+	float m_flMouseLastY;
+	float m_flLastSteamPadScroll;
+	uint32 m_unSteamPadScrollRepeats;
+
+	panorama::HtmlFormHasFocus_t m_evtFocus;		// used for saving state of controls that have focus info dispatched
+
+	bool m_bPendingInputZoom; // true if we are zooming into an input element
+	bool m_bFocusEventSentForClick; // time we sent a focus event to the browser
+	bool m_bDidMousePanWhileMouseDown; // did we do panning with the mouse held down
+	bool m_bWaitingForZoomResponse;
+
+	Vector2D m_LastSteamRightPad;
+
+	panorama::CTextTooltip *m_pTooltip;
+	bool m_bGotKeyDown;
+#if defined( SOURCE2_PANORAMA ) || defined( PANORAMA_PUBLIC_STEAM_SDK )
+	HHTMLBrowser m_HTMLBrowser;
+	void OnBrowserReady( HTML_BrowserReady_t *pBrowserReady, bool bIOFailure );
+	CCallResult< CHTML, HTML_BrowserReady_t > m_SteamCallResultBrowserReady;
+
+	CPanelPtr< CFileOpenDialog > m_pFileOpenDialog;
+	
+	CUtlVector<HHTMLBrowser> m_vecDenyNewBrowserWindows;
+#else
+	CChromePaintBufferClient m_SharedPaintBuffer;
+#endif
+
+	int m_nPopupX;
+	int m_nPopupY;
+	int m_nPopupWide;
+	int m_nPopupTall;
+	int m_nTextureSerialCombo;
+	CUtlBuffer m_ComboTexture;
+	CHTML *m_pPopupChild;
+
+	CThreadMutex m_mutexHTMLTexture;
+	CThreadMutex m_mutexScreenShot;
+	CUtlBuffer m_bufScreenshotTexture;
+	float m_flScrollRemainder;
+	int m_nTargetHorizontalScrollValue;
+	int m_nTargetVerticalScrollValue;
+	bool m_bControlPageScrolling;
+
+	// virtual mouse used when steam controller is connected
+	IVirtualMouse *m_pLeftMousePad;
+	Vector2D m_vecVirtualScrollPrev;
+	Vector2D m_vecVirtualScrollOrigin;
+	bool m_bVerticalAxisSnap;
+	bool m_bClickingLeftPad;
+	bool m_bMarkZoomStart;
+	float m_flInitialZoomLevel;
+	float m_flZoomSwipeOriginPosition;
+
+	static const float s_fScrollDeadzoneScale;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+class CHTMLSimpleNavigationWrapper : public CPanel2D
+{
+	DECLARE_PANEL2D( CHTMLSimpleNavigationWrapper, CPanel2D );
+
+public:
+	CHTMLSimpleNavigationWrapper( CPanel2D *pParent, const char *pchPanelID );
+
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+
+	virtual bool OnGamePadDown( const GamePadData_t &code ) OVERRIDE;
+	virtual bool OnGamePadAnalog( const GamePadData_t &code ) OVERRIDE;
+	virtual bool OnMouseWheel( const MouseData_t &code ) OVERRIDE;
+
+private:
+	void EnsureHTMLPanelReference();
+
+private:
+	CHTML *m_pHTML;
+	CPanoramaSymbol m_symWrappedHTMLID;
+	bool m_bInEventProcessing;
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_HTML_H
diff --git a/public/panorama/controls/image.h b/public/panorama/controls/image.h
new file mode 100644
index 0000000..3c75637
--- /dev/null
+++ b/public/panorama/controls/image.h
@@ -0,0 +1,121 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_IMAGEPANEL_H
+#define PANORAMA_IMAGEPANEL_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "../data/iimagesource.h"
+
+namespace panorama
+{
+
+DECLARE_PANEL_EVENT1( SetImageSource, const char * );
+DECLARE_PANEL_EVENT0( ClearImageSource );
+enum EImageScaling
+{
+	k_EImageScalingNone,
+	k_EImageScalingStretchBoth,
+	k_EImageScalingStretchX,
+	k_EImageScalingStretchY,
+	k_EImageScalingStretchBothToFitPreserveAspectRatio,
+	k_EImageScalingStretchXToFitPreserveAspectRatio,
+	k_EImageScalingStretchYToFitPreserveAspectRatio,
+	k_EImageScalingStretchBothToCoverPreserveAspectRatio
+};
+
+enum EImageHorizontalAlignment
+{
+	k_EImageHorizontalAlignmentCenter,
+	k_EImageHorizontalAlignmentLeft,
+	k_EImageHorizontalAlignmentRight,
+};
+
+enum EImageVerticalAlignment
+{
+	k_EImageVerticalAlignmentCenter,
+	k_EImageVerticalAlignmentTop,
+	k_EImageVerticalAlignmentBottom,
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: ImagePanel
+//-----------------------------------------------------------------------------
+class CImagePanel : public CPanel2D
+{
+	DECLARE_PANEL2D( CImagePanel, CPanel2D );
+
+public:
+	CImagePanel( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CImagePanel();
+
+	virtual void Paint();
+	virtual bool BSetProperties( const CUtlVector< ParsedPanelProperty_t > &vecProperties );
+
+	bool OnImageLoaded( const CPanelPtr< IUIPanel > &pPanel, IImageSource *pImage );
+	bool OnSetImageSource( const CPanelPtr<IUIPanel> &pPanel, const char *pchImageSource );
+	bool OnClearImageSource( const CPanelPtr<IUIPanel> &pPanel );
+
+	IImageSource *GetImage() { return m_pImage; }
+
+	// Set an image from a URL (file://, http://), if pchDefaultImage is specified it must be a file:// url and will be
+	// used while the actual image is loaded asynchronously, it will also remain in use if the actual image fails to load
+	void SetImage( const char *pchImageURL, const char *pchDefaultImageURL = NULL, bool bPrioritizeLoad = false, int nResizeWidth = -1, int nResizeHeight = -1 );
+
+	// Set an image from an already created IImageSource, you should almost always use the simpler SetImage( pchImageURL, pchDefaultImageURL ) call.
+	void SetImage( IImageSource *pImage );
+
+	void Clear();
+	bool IsSet() { return (m_pImage != NULL); }
+
+	void SetScaling( EImageScaling eScale );
+	void SetScaling( CPanoramaSymbol symScale );
+	void SetAlignment( EImageHorizontalAlignment horAlign, EImageVerticalAlignment verAlign );
+	void SetVisibleImageSlice( int nX, int nY, int nWidth, int nHeight );
+
+	virtual void  SetupJavascriptObjectTemplate() OVERRIDE;
+
+	void GetDebugPropertyInfo( CUtlVector< DebugPropertyOutput_t *> *pvecProperties );
+
+	virtual bool BRequiresContentClipLayer();
+
+	void SetImageJS( const char *pchImageURL );
+
+	virtual bool IsClonable() OVERRIDE { return AreChildrenClonable(); }
+	virtual CPanel2D *Clone() OVERRIDE;
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
+#endif
+
+protected:
+	virtual void OnContentSizeTraverse( float *pflContentWidth, float *pflContentHeight, float flMaxWidth, float flMaxHeight, bool bFinalDimensions );
+
+	virtual void InitClonedPanel( CPanel2D *pPanel ) OVERRIDE;
+private:
+
+	EImageScaling m_eScaling;
+	EImageHorizontalAlignment m_eHorAlignment;
+	EImageVerticalAlignment m_eVerAlignment;
+	int m_nVisibleSliceX;
+	int m_nVisibleSliceY;
+	int m_nVisibleSliceWidth;
+	int m_nVisibleSliceHeight;
+	CUtlString m_strSource;
+	CUtlString m_strSourceDefault;
+	bool m_bAnimate;
+
+	IImageSource *m_pImage;
+	float m_flPrevAnimateWidth;
+	float m_flPrevAnimateHeight;
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_IMAGEPANEL_H
diff --git a/public/panorama/controls/label.h b/public/panorama/controls/label.h
new file mode 100644
index 0000000..01e1ffb
--- /dev/null
+++ b/public/panorama/controls/label.h
@@ -0,0 +1,232 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_LABEL_H
+#define PANORAMA_LABEL_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "panorama/localization/ilocalize.h"
+#include "panorama/text/iuitextlayout.h"
+
+namespace panorama
+{
+
+DECLARE_PANEL_EVENT0( CopySelectedLabelText );
+
+//-----------------------------------------------------------------------------
+// Purpose: Label
+//-----------------------------------------------------------------------------
+class CLabel : public CPanel2D, public ILocalizationStringSizeResolver
+{
+	DECLARE_PANEL2D( CLabel, CPanel2D );
+
+public:
+	CLabel( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CLabel();
+
+	virtual void Paint();
+	virtual bool BSetProperties( const CUtlVector< ParsedPanelProperty_t > &vecProperties );
+
+	virtual void SetupJavascriptObjectTemplate() OVERRIDE;
+
+	enum ETextType
+	{
+		k_ETextTypePlain,
+		k_ETextTypeUnlocalized,
+		k_ETextTypeHTML
+	};
+	virtual void SetText( const char *pchValue, ETextType eTextType = k_ETextTypePlain );
+	virtual void AppendText( const char *pchValue, ETextType eTextType = k_ETextTypePlain );
+	virtual const char *PchGetText() const { return m_pLocText ? m_pLocText->String() : ""; }	
+	
+	bool OnLocalizationChanged( const CPanelPtr< IUIPanel > &pPanel, const ILocalizationString *pString ); // can't be virtual as it is an event catcher
+	
+	void SetMaxChars( EStringTruncationStyle eTruncationStyle, uint32 nMaxChars );
+	void SetStyleForRange( int iStartIndex, int iEndIndex, CPanoramaSymbol symStyle );
+
+	virtual bool BRequiresContentClipLayer() { return m_bMayDrawOutsideBounds; }
+	virtual bool BAcceptsFocus() { return false; }
+
+	virtual bool GetContextUIBounds( float *pflX, float *pflY, float *pflWidth, float *pflHeight ) OVERRIDE;
+
+	bool BHasSelection() { return m_nSelectionEndIndex != -1; }
+	void CopySelectionToClipboard();
+
+	bool OnCopySelectedLabelText( const CPanelPtr< IUIPanel > &pPanel );
+
+	// for cloning
+	virtual bool IsClonable() { return AreChildrenClonable(); }
+	virtual CPanel2D *Clone();
+
+	// Get the count of anchor tags in this label, will be zero if not HTML
+	uint32 GetHREFCount();
+
+	// Get vector of all url targets in the label
+	void GetHREFTargets( CUtlVector< CUtlString > &vecTargets );
+
+	// enable or disable selection of text via mouse clicks
+	void SetAllowTextSelection( bool bAllow ) { m_bAllowTextSelection = bAllow; }
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
+	void ValidateLinkVector( CValidator &validator, CUtlVector< CUtlString > *pvecLinks );
+#endif
+
+	// Allow us to recalc HTML style flags on scale factor changes
+	virtual void OnUIScaleFactorChanged( float flScaleFactor ) OVERRIDE;
+
+	virtual void GetDebugPropertyInfo( CUtlVector< DebugPropertyOutput_t *> *pvecProperties ) OVERRIDE;
+
+	enum EHTMLFormatFlag
+	{
+		k_EHTMLFormatTagNone = 0,
+		k_EHTMLFormatTagAnchor = 1,
+		k_EHTMLFormatTagBold = 1 << 1,
+		k_EHTMLFormatTagItalics = 1 << 2,
+		k_EHTMLFormatTagEmphasized = 1 << 3,
+		k_EHTMLFormatTagStrong = 1 << 4,
+		k_EHTMLFormatTagSpan = 1 << 5,
+		k_EHTMLFormatTagHeader1 = 1 << 6,
+		k_EHTMLFormatTagHeader2 = 1 << 7,
+		k_EHTMLFormatTagFont = 1 << 8,
+		k_EHTMLFormatTagPre = 1 << 9,
+	};
+
+protected:
+	virtual void OnContentSizeTraverse( float *pflContentWidth, float *pflContentHeight, float flMaxWidth, float flMaxHeight, bool bFinalDimensions );
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+	virtual void OnStylesChanged();
+	virtual void OnMouseMove( float flMouseX, float flMouseY );
+	virtual bool OnMouseButtonDown( const MouseData_t &code );
+	virtual bool OnMouseButtonUp( const MouseData_t &code );
+	bool EventStyleFlagsChanged( const CPanelPtr< IUIPanel > &pPanel );
+	bool OnFindLongestStringForLocVariable( const CPanelPtr< IUIPanel > &pPanel );
+
+	virtual void InitClonedPanel( CPanel2D *pPanel );
+
+	virtual void SetTextFromJS(const char *pchValue) 
+	{ 
+		if( m_bParseAsHTML )
+			SetText( pchValue, k_ETextTypeHTML );
+		else
+			SetText( pchValue, k_ETextTypeUnlocalized );
+	}
+
+	bool BParseAsHTML() const { return m_bParseAsHTML; }
+	void SetParseAsHTML( bool bParseAsHTML ) { m_bParseAsHTML = bParseAsHTML; }
+
+private:
+	struct TextRangeFormat_t
+	{
+		static const Color k_colorUnspecified;
+
+		TextRangeFormat_t()
+		{
+			m_iStartChar = -1;
+			m_iEndChar = -1;
+			m_unHTMLFormatFlags = 0;
+			m_iHREF = -1;
+			m_iMouseOver = -1;
+			m_iMouseOut = -1;
+			m_iContextMenu = -1;
+			m_pStyle = NULL;
+			m_unStyleFlags = 0;
+			m_color = k_colorUnspecified;
+			m_bChildOwner = false;
+		}
+		
+		void CopyWithoutRecalcData( const TextRangeFormat_t &rhs );		
+
+#ifdef DBGFLAG_VALIDATE
+		virtual void Validate( CValidator &validator, const tchar *pchName );
+#endif
+
+		int m_iStartChar;
+		int m_iEndChar;
+
+		uint m_unHTMLFormatFlags;
+		CUtlVector< CPanoramaSymbol > m_vecClasses;
+		int m_iHREF;					// index into m_vecParsedHREFs if clickable. Multiple ranges could have the same URL, so hold indexes instead of copy strings
+		int m_iMouseOver;				// index into m_vecParsedMouseOvers if clickable. Multiple ranges could have the same URL, so hold indexes instead of copy strings
+		int m_iMouseOut;				// index into m_vecParsedMouseOuts if clickable. Multiple ranges could have the same URL, so hold indexes instead of copy strings
+		int m_iContextMenu;				// index into m_vecParsedContextMenus if clickable. Multiple ranges could have the same URL, so hold indexes instead of copy strings
+
+		IUIPanelStyle *m_pStyle;
+		uint m_unStyleFlags;
+
+		Color m_color;
+
+		CUtlString m_strChildID;
+		bool m_bChildOwner;
+
+		struct RangeFormatBox_t
+		{
+			Vector2D topLeft;
+			Vector2D bottomRight;
+		};
+
+		CUtlVector< RangeFormatBox_t > m_vecBoundingBoxes;
+	};
+
+	void SetTextInternal( const char *pchValue, ETextType eTextType, bool bTrustedSource );
+	void SetFromHTMLInternal( const char *pchText, bool bAppend, bool bTrusted );
+	int ParseStringFromTag( const char *pchTag, const char *pchString, CUtlVector<CUtlString> **ppVecStrings );
+	int ParseHREFFromTag( const char *pchTag );
+	int ParseMouseOverFromTag( const char *pchTag );
+	int ParseMouseOutFromTag( const char *pchTag );
+	int ParseContextMenuFromTag( const char *pchTag );
+	void UpdateTextRangeStyles();
+	TextRangeFormat_t &AppendTextRangeFormat( int iStartChar, int iEndChar, uint unHTMLFormatFlags, const CUtlVector< CPanoramaSymbol > &vecStyles, int iHREF, int iMouseOver, int iMouseOut, int iContextMenu, const Color &color, const char *pszChildID, bool bChildOwner );
+	void RemoveTextRangeFormats();
+	bool BCoordsInTextRange( const TextRangeFormat_t &rangeFormat, float flX, float flY );
+	int FindTextRangeAt( float flX, float flY );
+
+	IUITextLayout *CreateTextLayout( float flWidth, float flHeight, bool bUseChildDesiredSize, const char *pchOptStringToUse = NULL );
+	IUITextLayout *CreateCurrentLayoutTextLayout();
+	virtual int ResolveStringLengthInPixels( const char *pchString );
+
+	bool HandleAnchorTagEvent( CUtlVector< CUtlString > *pvecLinks, int iLinkIndex );
+
+	static void CloneLinksVector( CUtlVector< CUtlString > *pSourceLinks, CUtlVector< CUtlString > **ppDestinationLinks );
+
+	bool m_bContentSizeDirty;
+	float m_flMaxWidthLastContentSize;
+	float m_flMaxHeightLastContentSize;
+	float m_flLastUIScaleFactor;
+
+	bool m_bLeftMouseIsDown;
+	Vector2D m_LastMousePos;
+	bool m_bSelectionRectDirty;
+	int32 m_nSelectionStartIndex;
+	int32 m_nSelectionEndIndex;
+	CUtlVector<IUITextLayout::HitTestRegionRect_t> m_vecSelectionRects;
+
+	bool m_bMayDrawOutsideBounds;
+	bool m_bAllowTextSelection;
+	
+	CMutableLocalizationString m_pLocText;
+	CMutableLocalizationString m_pLocTextHTML; // the base string with html markup preserved
+	uint32 m_nMaxChars;										// max chars to store in this label
+	EStringTruncationStyle m_eStringTruncationStyle;		// how to truncate our text
+	bool m_bParseAsHTML;									// if true, set text will be parsed as html
+	CUtlVector< TextRangeFormat_t > m_vecTextRangeFormats;	// list of parsed text range formats
+	CUtlVector< CUtlString > *m_pvecParsedHREFs;			// parsed href.. indexes are added to text range formats. Multiple ranges could have same URL.
+	CUtlVector< CUtlString > *m_pvecParsedMouseOvers;		// parsed onmouseover.. indexes are added to text range formats. Multiple ranges could have same URL.
+	CUtlVector< CUtlString > *m_pvecParsedMouseOuts;		// parsed onmouseout.. indexes are added to text range formats. Multiple ranges could have same URL.
+	CUtlVector< CUtlString > *m_pvecParsedContextMenus;		// parsed oncontextmenu.. indexes are added to text range formats. Multiple ranges could have same URL.
+	TextRangeFormat_t *m_pLastHoverRange;					// last text range the mouse was hovering over	
+	TextRangeFormat_t *m_pMouseDownRange;					// index into m_vecTextRangeFormats
+
+	static uint32 s_unNextInlineImageID;
+};
+
+} // namespace panorama
+
+
+#endif // PANORAMA_LABEL_H
diff --git a/public/panorama/controls/listsegmentview.h b/public/panorama/controls/listsegmentview.h
new file mode 100644
index 0000000..e4ffc02
--- /dev/null
+++ b/public/panorama/controls/listsegmentview.h
@@ -0,0 +1,84 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef LIST_SEGMENT_VIEW_H
+#define LIST_SEGMENT_VIEW_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+
+DECLARE_PANEL_EVENT0( ListSegmentViewRetreat );
+DECLARE_PANEL_EVENT0( ListSegmentViewAdvance );
+
+DECLARE_PANORAMA_EVENT0( ListSegmentViewChanged );
+
+
+namespace panorama
+{
+	/*
+	
+	A class that handles displaying X sequential elements from its children.  Similar to a carousel, but more
+	minimal -- you handle advancing/retreating yourself.  Supports up to 10 visible elements.
+
+	Things you need to do:
+	- Specify "items-displayed:" in the xml, which is how many elements are shown at once.
+	- Specify "step-size:" in the xml, which is how many steps it'll move when advancing or retreating.  Cannot be bigger than items-displayed.
+	- Define these classes, which will be added to the child elements (X is always 1 through 10):
+	   .ListSegmentDisplayedX, one for each of the elements you intend to display.
+	   .ListSegmentHiddenBeforeX, one for each hidden element that's off the "top/left" of the display.  These guys are prior to the displayed window.
+	   .ListSegmentHiddenAfterX, one for each hidden element that's off the "bottom/right" of the display.  These guys are after the displayed window.
+	   .ListSegmentSnap, which eliminates any transitions you're using in your element class, so that elements just go directly to their displayed/hidden states immediately.
+
+	Then you just need to add children (in order) to it, and call AdvancePosition and RetreatPosition to move through them.
+
+	*/
+
+//-----------------------------------------------------------------------------
+// Purpose: List Segment View
+//-----------------------------------------------------------------------------
+class CListSegmentView : public CPanel2D
+{
+	DECLARE_PANEL2D( CListSegmentView, CPanel2D );
+
+public:
+	CListSegmentView( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CListSegmentView();
+
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+	virtual void GetDebugPropertyInfo( CUtlVector< DebugPropertyOutput_t *> *pvecProperties ) OVERRIDE;
+	
+	virtual void OnStylesChanged() OVERRIDE			{ UpdateChildrenStyles( false ); BaseClass::OnStylesChanged(); }
+	virtual void OnAfterChildrenChanged() OVERRIDE	{ UpdateChildrenStyles( false ); BaseClass::OnAfterChildrenChanged(); }
+
+	virtual bool BRequiresContentClipLayer() OVERRIDE { return true; }
+
+	bool RetreatPosition( const CPanelPtr< IUIPanel > &panelPtr );
+	bool AdvancePosition( const CPanelPtr< IUIPanel > &panelPtr );
+
+	int GetCurrentPage( void );
+	int GetNumPages( void );
+
+	bool IsAtStart( void );
+	bool IsAtEnd( void );
+
+	void ResetPosition( void );
+
+private:
+
+	void UpdateChildrenStyles( bool bSnap );
+
+	int m_nItemsDisplayed;
+	int m_nStepSize;
+
+	int m_nCurrentChildIndex;
+};
+
+
+} // namespace panorama
+
+#endif // LIST_SEGMENT_VIEW_H
diff --git a/public/panorama/controls/mousescroll.h b/public/panorama/controls/mousescroll.h
new file mode 100644
index 0000000..62ee5eb
--- /dev/null
+++ b/public/panorama/controls/mousescroll.h
@@ -0,0 +1,53 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef MOUSESCROLL_H
+#define MOUSESCROLL_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "mathlib/mathlib.h"
+#include "mathlib/beziercurve.h"
+#include "panel2d.h"
+#include "panorama/controls/label.h"
+#include "panorama/controls/mousescroll.h"
+#include "panorama/uischeduleddel.h"
+
+
+namespace panorama
+{
+DECLARE_PANEL_EVENT1( MouseScroll, int );
+
+//-----------------------------------------------------------------------------
+// Purpose: Panel which is the clickable mouse region to scroll a carousel or other horizontal list type panel
+//-----------------------------------------------------------------------------
+class CMouseScrollRegion : public CPanel2D
+{
+	DECLARE_PANEL2D( CMouseScrollRegion, CPanel2D );
+
+public:
+	CMouseScrollRegion( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CMouseScrollRegion();
+	
+	virtual bool OnMouseButtonDown( const MouseData_t &code );
+	virtual bool OnMouseButtonDoubleClick( const MouseData_t &code );
+	virtual bool OnMouseButtonTripleClick( const MouseData_t &code );
+	virtual bool OnMouseButtonUp( const MouseData_t &code );
+
+private:
+	void DispatchScrollEvent();
+	void MouseButtonDown();	
+
+	CCubicBezierCurve< Vector2D > m_repeatCurve;
+	panorama::CUIScheduledDel m_scheduledScrollRepeat;
+	double m_flMouseDownTimestamp;
+	int m_cMouseDownRepeats;
+};
+
+} // namespace panorama
+
+#endif // MOUSESCROLL_H
diff --git a/public/panorama/controls/movieplayer.h b/public/panorama/controls/movieplayer.h
new file mode 100644
index 0000000..b76f100
--- /dev/null
+++ b/public/panorama/controls/movieplayer.h
@@ -0,0 +1,320 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_MOVIEPLAYER_H
+#define PANORAMA_MOVIEPLAYER_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "../data/iimagesource.h"
+#include "../data/panoramavideoplayer.h"
+#include "panorama/uischeduleddel.h"
+
+namespace panorama
+{
+class CToggleButton;
+class CLabel;
+class CSlider;
+
+DECLARE_PANEL_EVENT0( MoviePlayerAudioStart );
+DECLARE_PANEL_EVENT0( MoviePlayerAudioStop );
+DECLARE_PANEL_EVENT0( MoviePlayerPlaybackStart );
+DECLARE_PANEL_EVENT0( MoviePlayerPlaybackStop );
+DECLARE_PANEL_EVENT1( MoviePlayerPlaybackEnded, EVideoPlayerPlaybackError );
+DECLARE_PANORAMA_EVENT0( MoviePlayerTogglePlayPause );
+DECLARE_PANORAMA_EVENT0( MoviePlayerFastForward );
+DECLARE_PANEL_EVENT0( MoviePlayerUIVisible );
+DECLARE_PANORAMA_EVENT0( MoviePlayerJumpBack );
+DECLARE_PANORAMA_EVENT0( MoviePlayerVolumeControl );
+DECLARE_PANORAMA_EVENT0( MoviePlayerFullscreenControl );
+DECLARE_PANORAMA_EVENT1( MoviePlayerSetRepresentation, int );
+DECLARE_PANORAMA_EVENT0( MoviePlayerSelectVideoQuality );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Base class for controls that pop above movie button bar
+//-----------------------------------------------------------------------------
+class CMovieControlPopupBase : public CPanel2D
+{
+public:
+	CMovieControlPopupBase( CPanel2D *pInvokingPanel, const char *pchPanelID );
+	virtual ~CMovieControlPopupBase() {}
+
+	void Show( float flVolume );
+	void Close();
+
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight ) OVERRIDE;
+
+protected:
+	bool EventCancelled( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+
+	CPanel2D *m_pInvisibleBackground;
+	CPanel2D *m_pInvokingPanel;
+	CPanel2D *m_pPopupBackground;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Top level menu for volume slider
+//-----------------------------------------------------------------------------
+class CVolumeSliderPopup : public CMovieControlPopupBase
+{
+	DECLARE_PANEL2D( CVolumeSliderPopup, CMovieControlPopupBase );
+
+public:
+	CVolumeSliderPopup( CPanel2D *pInvokingPanel, const char *pchPanelID );
+	virtual ~CVolumeSliderPopup() {}
+
+	void Show( float flVolume );
+	virtual bool OnKeyDown( const KeyData_t &unichar ) OVERRIDE;
+
+private:
+	bool EventSliderValueChanged( const CPanelPtr< IUIPanel > &pPanel, float flValue );
+	
+	CSlider *m_pSlider;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Top level menu for showing video resolutions to select
+//-----------------------------------------------------------------------------
+class CMovieVideoQualityPopup : public CMovieControlPopupBase
+{
+	DECLARE_PANEL2D( CMovieVideoQualityPopup, CMovieControlPopupBase );
+
+public:
+	CMovieVideoQualityPopup( CPanel2D *pInvokingPanel, const char *pchPanelID );
+	virtual ~CMovieVideoQualityPopup() {}
+
+	void AddRepresentation( int iRep, int nHeight );
+	void Show( int iFocusRep, int nVideoHeight );
+
+private:
+	struct Representation_t
+	{
+		int m_iRep;
+		int m_nHeight;
+	};
+
+	bool EventSetRepresentation( int iRep );
+	static bool SortRepresentations( const Representation_t &lhs, const Representation_t &rhs );
+	
+	CUtlVector< Representation_t > m_vecRepresentations;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Movie panel. Just displays the movie
+//-----------------------------------------------------------------------------
+class CMoviePanel : public CPanel2D
+{
+	DECLARE_PANEL2D( CMoviePanel, CPanel2D );
+
+public:
+	CMoviePanel( CPanel2D *parent, const char *pchPanelID );
+	virtual ~CMoviePanel();
+
+	CVideoPlayerPtr GetMovie() { return m_pVideoPlayer; }
+	void SetMovie( const char *pchFile );
+	void SetMovie( CVideoPlayerPtr pVideoPlayer );
+	bool IsSet() { return (m_pVideoPlayer != NULL); }
+	void Clear();
+	void SetPlaybackVolume( float flVolume );
+	void SuggestMovieHeight();
+
+	virtual void Paint();
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
+#endif
+
+protected:
+	virtual void OnContentSizeTraverse( float *pflContentWidth, float *pflContentHeight, float flMaxWidth, float flMaxHeight, bool bFinalDimensions ) OVERRIDE;
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight ) OVERRIDE;	
+	bool EventVideoPlayerInitialized( IVideoPlayer *pIMovie );
+
+private:
+	CVideoPlayerPtr m_pVideoPlayer;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays debug info for a movie
+//-----------------------------------------------------------------------------
+class CMovieDebug : public CPanel2D
+{
+	DECLARE_PANEL2D( CMovieDebug, CPanel2D );
+
+public:
+	CMovieDebug( CPanel2D *pParent, const char *pchID );
+	virtual ~CMovieDebug() {}
+
+	void Show( CVideoPlayerPtr pVideoPlayer );
+
+private:
+	void Update();
+
+	CVideoPlayerPtr m_pVideoPlayer;
+	CLabel *m_pDimensions;
+	CLabel *m_pResolution;
+	CLabel *m_pFileType;
+	CLabel *m_pVideoSegment;
+	CLabel *m_pVideoBandwidth;
+
+	panorama::CUIScheduledDel m_scheduledUpdate;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Movie player. Includes UI
+//-----------------------------------------------------------------------------
+class CMoviePlayer : public CPanel2D
+{
+	DECLARE_PANEL2D( CMoviePlayer, CPanel2D );
+
+public:
+	CMoviePlayer( CPanel2D *parent, const char *pchPanelID );
+	virtual ~CMoviePlayer();
+
+	virtual void SetupJavascriptObjectTemplate() OVERRIDE;
+
+	CVideoPlayerPtr GetMovie() { return m_pMoviePanel->GetMovie(); }
+	void SetMovie( const char *pchFile );
+	void SetMovie( CVideoPlayerPtr pVideoPlayer );
+	bool IsSet() { return m_pMoviePanel->IsSet(); }
+	void Clear();
+
+	enum EAutoplay
+	{
+		k_EAutoplayOff,
+		k_EAutoplayOnLoad,
+		k_EAutoplayOnFocus
+	};
+
+	enum EControls
+	{
+		k_EControlsNone,
+		k_EControlsMinimal,
+		k_EControlsFull,
+		k_EControlsInvalid
+	};
+
+	void SetAutoplay( EAutoplay eAutoPlay, bool bSkipPlay = false );
+	void SetRepeat( bool bRepeat );
+	void SetControls( EControls eControls );
+	void SetControls( const char *pchControls );
+
+
+	virtual bool OnGamePadDown( const GamePadData_t &code ) OVERRIDE;
+	virtual bool OnKeyTyped( const KeyData_t &unichar ) OVERRIDE;
+	virtual panorama::IUIPanel *OnGetDefaultInputFocus() OVERRIDE;
+
+	void Play();
+	void Pause();
+	void Stop();
+	void TogglePlayPause();
+	void FastForward();
+	void Rewind();
+	void SetPlaybackVolume( float flVolume );
+
+	// title control
+	void SetTitleText( const char *pchText );
+	void ShowTitle( bool bImmediatelyVisible = false );
+	void HideTitle();
+	bool BAdjustingVolume();
+
+	virtual bool OnMouseButtonDown( const MouseData_t &code );
+
+protected:
+	virtual bool BSetProperties( const CUtlVector< ParsedPanelProperty_t > &vecProperties );
+
+	static EControls EControlsFromString( const char *pchControls );
+
+	bool EventInputFocusSet( const CPanelPtr< IUIPanel > &ptrPanel );
+	bool EventInputFocusLost( const CPanelPtr< IUIPanel > &ptrPanel );
+	bool EventMovieInitialized( IVideoPlayer *pIMovie );
+	bool EventVideoPlayerPlaybackStateChanged( IVideoPlayer *pIMovie );
+	bool EventVideoPlayerChangedRepresentation( IVideoPlayer *pIMovie );
+	bool EventVideoPlayerEnded( IVideoPlayer *pIMovie );
+	bool EventActivated( const CPanelPtr< IUIPanel > &ptrPanel, EPanelEventSource_t eSource );
+	bool EventCancelled( const CPanelPtr< IUIPanel > &ptrPanel, EPanelEventSource_t eSource );
+	bool EventMovieTogglePlayPause();
+	bool EventMoviePlayerFastForward();
+	bool EventMoviePlayerJumpBack();
+	bool EventMoviePlayerVolumeControl();
+	bool EventMoviePlayerSelectQuality();
+	bool EventSoundVolumeChanged( ESoundType eSoundType, float flVolume );
+	bool EventSoundMuteChanged( bool bMute );
+	bool EventSetRepresentation( int iRep );
+
+	void UpdateFullUI();
+	void UpdateTimeline();
+	void UpdatePlayPauseButton();
+	void UpdatePlaybackSpeed();
+	void Seek( uint unOffset );
+	void RaisePlaybackStartEvents();
+	void RaisePlaybackStopEvents();
+	void DisplayControls( bool bVisible );
+	void DisplayTimeline( bool bVisible );
+	bool BAnyControlsVisible();
+	bool BControlBarVisible();
+	bool BTimelineVisible();
+	void UpdateMovingPlayingStyle();
+	void UpdateVolumeControls();
+	void SetAudioVolumeStyle( CPanoramaSymbol symStyle );
+
+	void ShowTitleInternal( bool bImmediatelyVisible = false );
+	void HideTitleInternal();
+
+private:
+	CMoviePanel *m_pMoviePanel;
+	CPanelPtr< CMovieDebug > m_ptrDebug;
+
+	// minimal UI
+	CPanel2D *m_pLoadingThrobber;
+	CPanel2D *m_pPlayIndicator;
+	CPanoramaSymbol m_symMoviePlaybackStyle;
+
+	// title sections
+	CPanel2D *m_pPlaybackTitleAndControls;
+	CLabel *m_pPlaybackTitle;
+	bool m_bExternalShowTitle;
+
+	// full UI
+	CPanel2D *m_pPlaybackControls;
+	CPanel2D *m_pPlaybackProgressBar;
+	CToggleButton *m_pPlayPauseBtn;
+	CLabel *m_pPlaybackSpeed;
+	CPanel2D *m_pTimeline;
+	CPanel2D *m_pControlBarRow;
+	CPanel2D *m_pVolumeControl;
+	CLabel *m_pErrorMessage;
+	CPanelPtr< CVolumeSliderPopup > m_ptrVolumeSlider;
+	CPanelPtr< CMovieVideoQualityPopup > m_ptrVideoQualityPopup;
+	CButton *m_pVideoQualityBtn;
+
+	bool m_bInConstructor;
+	bool m_bRaisedAudioStartEvent;
+	bool m_bRaisedPlaybackStartEvent;
+	bool m_bHadFocus;
+	bool m_bCloseControlsOnPlay;
+
+	EAutoplay m_eAutoplay;
+	EControls m_eControls;
+	bool m_bDisableActivatePause;
+	bool m_bShowControlsNotFullscreen;
+	bool m_bRepeat;
+	bool m_bMuted;								// muted flag
+	float m_flVolume;							// playback volume, defaults to movie volume setting
+	int m_iDesiredVideoRepresentation;			// representation selected by user or -1. Video player might not yet have changed to playing this rep
+};
+
+
+} // namespace panorama
+
+#endif // PANORAMA_MOVIEPLAYER_H
diff --git a/public/panorama/controls/panel2d.h b/public/panorama/controls/panel2d.h
new file mode 100644
index 0000000..a514708
--- /dev/null
+++ b/public/panorama/controls/panel2d.h
@@ -0,0 +1,1109 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANEL2D_H
+#define PANEL2D_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "../iuiengine.h"
+#include "../iuipanel.h"
+#include "../iuipanelclient.h"
+#include "../iuipanelstyle.h"
+#include "panorama/transformations.h"
+#include "panorama/input/keycodes.h"
+#include "panorama/layout/panel2dfactory.h"
+#include "panorama/layout/stylefiletypes.h"
+#include "panorama/input/mousecursors.h"
+#include "panorama/input/iuiinput.h"
+#include "panorama/uieventcodes.h"
+#include "panorama/uievent.h"
+#include "panorama/iuiwindow.h"
+#include "panorama/layout/panel2dfactory.h"
+#include "color.h"
+#include "utlvector.h"
+#include "utlstring.h"
+#include "panelptr.h"
+#include "steam/steamtypes.h"
+#if defined( SOURCE2_PANORAMA )
+#include "currencyamount.h"
+#else
+#include "rtime.h"
+#include "amount.h"
+#endif
+#include "tier1/utlmap.h"
+#include "panorama/layout/stylesymbol.h"
+
+namespace panorama
+{
+
+#pragma warning(push)
+// warning C4251: 'CPanel2D::symbol' : class 'CUtlSymbol' needs to have dll-interface to be used by clients of class 'CPanel2D'
+#pragma warning( disable : 4251 ) 
+
+class CLayoutFile;
+class CTopLevelWindow;
+class CVerticalScrollBar;
+class CHorizontalScrollBar;
+struct PanelDescription_t;
+class CUIRenderEngine;
+class CImageResourceManager;
+class CPanelStyle;
+class CBackgroundImageLayer;
+class CPanel2D;
+class CScrollBar;
+
+// Typedefs for getter/setter methods that can be exposed via JS
+typedef float(CPanel2D::*PanelFloatGetter_t)() const;
+typedef void(CPanel2D::*PanelFloatSetter_t)(float);
+typedef const char *(CPanel2D::*PanelStringGetter_t)() const;
+typedef void(CPanel2D::*PanelStringSetter_t)(const char *);
+typedef bool(CPanel2D::*PanelBoolGetter_t)() const;
+typedef void(CPanel2D::*PanelBoolSetter_t)(bool);
+typedef CPanoramaSymbol( CPanel2D::*PanelSymbolGetter_t )() const;
+typedef void(CPanel2D::*PanelSymbolSetter_t)(CPanoramaSymbol);
+
+inline CPanel2D * ToPanel2D( IUIPanel *pPanel )
+{
+	if( pPanel )
+		return (CPanel2D*)(pPanel->ClientPtr());
+
+	return NULL;
+}
+
+	
+//-----------------------------------------------------------------------------
+// Purpose: Struct used to perform hit tests
+//-----------------------------------------------------------------------------
+struct TransformContext_t
+{
+	float m_flPosX;
+	float m_flPosY;
+	float m_flPosZ;
+	VMatrix m_TransformMatrix;
+	float m_flWidth;
+	float m_flHeight;
+
+	float m_flPerspective;
+	float m_flPerspectiveOriginX;
+	float m_flPerspectiveOriginY;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Basic 2D UI panel.  These may be transformed in 3D space, but they are 
+// at a base level 2D rectangular containers for other panels/paint operations.
+//-----------------------------------------------------------------------------
+class CPanel2D : public panorama::IUIPanelClient
+{
+	DECLARE_PANEL2D_NO_BASE( CPanel2D );
+
+public:
+	CPanel2D( IUIWindow *parent, const char * pchID );
+	CPanel2D( CPanel2D *parent, const char * pchID );
+	CPanel2D( CPanel2D *parent, const char *pchID, uint32 ePanelFlags );
+
+	virtual ~CPanel2D();
+
+	// Check if the panel has loaded layout
+	bool IsLoaded() const { return m_pIUIPanel->IsLoaded(); }
+
+	virtual void OnDeletePanel() OVERRIDE { delete this; }
+
+	// Access the panorama side UI panel interface for the client panel
+	virtual IUIPanel *UIPanel() const { return m_pIUIPanel; }
+
+	void DeleteAsync( float flDelay = 0.0f );
+
+	// Set the panel visible
+	void SetVisible( bool bVisible ) { m_pIUIPanel->SetVisible( bVisible ); }
+	bool BIsVisible() const { return m_pIUIPanel->BIsVisible(); }
+
+	// Get the base position for the panel
+	void GetPosition( CUILength &x, CUILength &y, CUILength &z, bool bIncludeUIScaleFactor = true );
+
+	// Set the base position for the panel
+	void SetPosition( CUILength x, CUILength y, CUILength z, bool bPreScaledByUIScaleFactor = false );
+	void SetPositionWithoutTransition( CUILength x, CUILength y, CUILength z, bool bPreScaledByUIScaleFactor = false );
+	void SetTransform3D( const CUtlVector<CTransform3D *> &vecTransforms );
+	void SetOpacity( float flOpacity );
+	bool BIsTransparent() { return m_pIUIPanel->BIsTransparent();  }
+	void SetPreTransformScale2D( float flX, float flY );
+
+	// Set the base width/height for the panel
+	CUILength GetStyleWidth();
+	CUILength GetStyleHeight();
+	void SetSize( CUILength width, CUILength height );
+
+	// The the bounds that should be used for placing a tooltip, returning false means "use the entire panel"
+	virtual bool GetContextUIBounds( float *pflX, float *pflY, float *pflWidth, float *pflHeight ) { return false; }
+
+	// Set the animation style for the panel
+	void SetAnimation( const char *pchAnimationName, float flDuration, float flDelay, EAnimationTimingFunction eTimingFunc, EAnimationDirection eDirection, float flIterations ) { m_pIUIPanel->SetAnimation( pchAnimationName, flDuration, flDelay, eTimingFunc, eDirection, flIterations ); }
+
+	// Returns the layout file for this panel
+	CPanoramaSymbol GetLayoutFile() const { return m_pIUIPanel->GetLayoutFile(); }
+
+	// Returns define from layout file for this panel
+	char const * GetLayoutFileDefine( char const *szDefineName );
+	int GetLayoutFileDefineInt( const char *szDefineName, int defaultValue );
+	float GetLayoutFileDefineFloat( const char *szDefineName, float defaultValue );
+
+	// Style access
+	panorama::IUIPanelStyle *AccessStyle() const { return m_pIUIPanel->AccessIUIStyle(); }
+
+	// Style access
+	panorama::IUIPanelStyle *AccessStyleDirty() const { return m_pIUIPanel->AccessIUIStyleDirty(); }
+
+	void ApplyStyles( bool bTraverse ) { return m_pIUIPanel->ApplyStyles( bTraverse ); }
+
+	// Mark styles dirty for the panel
+	void MarkStylesDirty( bool bIncludeChildren ) { m_pIUIPanel->MarkStylesDirty( bIncludeChildren ); }
+
+	void ClearPropertyFromCode( panorama::CStyleSymbol symProperty );
+
+	// Virtual called on scale factor for panel changing
+	virtual void OnUIScaleFactorChanged( float flScaleFactor ) OVERRIDE { }
+
+	// Paint the panel and it's children, called by the rendering layer when it's time to paint.
+	void PaintTraverse() { m_pIUIPanel->PaintTraverse(); }
+
+	// Paint the panels contents
+	virtual void Paint() OVERRIDE;
+
+	// Invalidates painting and tells the panel it must repaint next frame
+	void SetRepaint( EPanelRepaint eRepaintNeeded );
+
+	// sets & loads the layout file for this panel
+	bool BLoadLayout( const char *pchFile, bool bOverrideExisting = false, bool bPartialLayout = false ) { return m_pIUIPanel->BLoadLayout( pchFile, bOverrideExisting, bPartialLayout ); }
+
+	// sets & loads the layout for this panel
+	bool BLoadLayoutFromString( const char *pchXMLString, bool bOverrideExisting = false, bool bPartialLayout = false ) { return m_pIUIPanel->BLoadLayoutFromString( pchXMLString, bOverrideExisting, bPartialLayout ); }
+
+	// sets loads the layout file for this panel, asynchronously supporting remote http:// paths
+	void LoadLayoutAsync( const char *pchFile, bool bOverrideExisting = false, bool bPartialLayout = false ) { return m_pIUIPanel->LoadLayoutAsync( pchFile, bOverrideExisting, bPartialLayout ); }
+
+	// loads the layout file for this panel, asynchronously supporting remote http:// paths in css within
+	void LoadLayoutFromStringAsync( const char *pchXMLString, bool bOverrideExisting, bool bPartialLayout = false ) { return m_pIUIPanel->LoadLayoutFromStringAsync( pchXMLString, bOverrideExisting, bPartialLayout );  }
+
+	// Measure self and children. First pass of layout
+	void DesiredLayoutSizeTraverse( float flMaxWidth, float flMaxHeight ) { m_pIUIPanel->DesiredLayoutSizeTraverse( flMaxWidth, flMaxHeight ); }
+	void DesiredLayoutSizeTraverse( float *pflDesiredWidth, float *pflDesiredHeight, float flMaxWidth, float flMaxHeight, bool bFinalDimensions ) { m_pIUIPanel->DesiredLayoutSizeTraverse( pflDesiredWidth, pflDesiredHeight, flMaxWidth, flMaxHeight, bFinalDimensions );  }
+
+	// Arrange children. Second pass of layout
+	void LayoutTraverse( float x, float y, float flFinalWidth, float flFinalHeight ) { m_pIUIPanel->LayoutTraverse( x, y, flFinalWidth, flFinalHeight ); }
+
+	// methods to invalid certain parts of layout
+	void InvalidateSizeAndPosition() { m_pIUIPanel->InvalidateSizeAndPosition(); }
+	void InvalidatePosition() { m_pIUIPanel->InvalidatePosition(); }
+	bool IsSizeValid() { return  m_pIUIPanel->IsSizeValid(); }
+	bool IsPositionValid() { return m_pIUIPanel->IsPositionValid(); }
+	bool IsChildSizeValid() { return m_pIUIPanel->IsChildSizeValid(); }
+	bool IsChildPositionValid() { return m_pIUIPanel->IsChildPositionValid(); }
+	bool IsSizeTransitioning() { return m_pIUIPanel->IsSizeTransitioning(); }
+	bool IsPositionTransitioning() { return m_pIUIPanel->IsPositionTransitioning(); }
+	bool IsChildPositionTransitioning() { return m_pIUIPanel->IsChildPositionTransitioning(); }
+	bool IsChildSizeTransitioning() { return m_pIUIPanel->IsChildSizeTransitioning(); }
+
+	// size getters
+	float GetDesiredLayoutWidth() const { return m_pIUIPanel->GetDesiredLayoutWidth(); }
+	float GetDesiredLayoutHeight() const { return m_pIUIPanel->GetDesiredLayoutHeight(); }
+
+	// Content size is what our contents actually take up, not accounting for fixed/relative
+	// size set on us in styles which affect desired layout size
+	float GetContentWidth() const { return m_pIUIPanel->GetContentWidth(); }
+	float GetContentHeight() const { return m_pIUIPanel->GetContentHeight(); }
+
+	// Actual size is the size given to the panel after layout, hopefully as big as its desired size.  
+	// Actual size does NOT include margins (which are really in the parent).
+	float GetActualLayoutWidth() const { return m_pIUIPanel->GetActualLayoutWidth(); }
+	float GetActualLayoutHeight() const { return m_pIUIPanel->GetActualLayoutHeight(); }
+
+	// Render size is the size of the content for rendering, this is either the actual layout size, or if
+	// that is smaller than the content size + padding then it's the content size + padding.
+	float GetActualRenderWidth() { return m_pIUIPanel->GetActualRenderWidth(); }
+	float GetActualRenderHeight() { return m_pIUIPanel->GetActualRenderHeight(); }
+
+	// Offset will include position, alignment, and margin adjustments
+	float GetActualXOffset() const { return m_pIUIPanel->GetActualXOffset(); }
+	float GetActualYOffset() const { return m_pIUIPanel->GetActualYOffset(); }
+
+	// Offset to apply to contents for scrolling
+	float GetContentsYScrollOffset() const { return m_pIUIPanel->GetContentsYScrollOffset(); }
+	float GetContentsXScrollOffset() const { return m_pIUIPanel->GetContentsXScrollOffset(); }
+	float GetContentsYScrollOffsetTarget() const { return m_pIUIPanel->GetContentsYScrollOffsetTarget(); }
+	float GetContentsXScrollOffsetTarget() const { return m_pIUIPanel->GetContentsXScrollOffsetTarget(); }
+	double GetContentsXScrollTransitionStart() const { return m_pIUIPanel->GetContentsXScrollTransitionStart(); }
+	double GetContentsYScrollTransitionStart() const { return m_pIUIPanel->GetContentsYScrollTransitionStart(); }
+	float GetInterpolatedXScrollOffset() { return m_pIUIPanel->GetInterpolatedXScrollOffset(); }
+	float GetInterpolatedYScrollOffset() { return m_pIUIPanel->GetInterpolatedYScrollOffset(); }
+
+	// Can the panel scroll further?
+	bool BCanScrollUp() { return m_pIUIPanel->BCanScrollUp();  }
+	bool BCanScrollDown() { return m_pIUIPanel->BCanScrollDown();  }
+	bool BCanScrollLeft() { return m_pIUIPanel->BCanScrollLeft(); }
+	bool BCanScrollRight() { return m_pIUIPanel->BCanScrollRight(); }
+
+	// style class management
+	void AddClass( const char *pchName ) { m_pIUIPanel->AddClass( pchName ); }
+	void AddClass( CPanoramaSymbol symbol ) { m_pIUIPanel->AddClass( symbol ); }
+	void AddClasses( const char *pchName ) { m_pIUIPanel->AddClasses( pchName ); }
+	void AddClasses( CPanoramaSymbol *pSymbols, uint cSymbols ) { m_pIUIPanel->AddClasses( pSymbols, cSymbols ); }
+	void RemoveClass( const char *pchName ) { m_pIUIPanel->RemoveClass( pchName ); }
+	void RemoveClass( CPanoramaSymbol symName ) { m_pIUIPanel->RemoveClass( symName ); }
+	void RemoveClasses( const CPanoramaSymbol *pSymbols, uint cSymbols ) { m_pIUIPanel->RemoveClasses( pSymbols, cSymbols ); }
+	void RemoveClasses( const char *pchName ) { m_pIUIPanel->RemoveClasses( pchName ); }
+	void RemoveAllClasses() { m_pIUIPanel->RemoveAllClasses(); }
+
+	// bugbug jmccaskey - dangerous cross dll interface signature?  Is CUtlVector the same in debug/release?
+	const CUtlVector< CPanoramaSymbol > &GetClasses() const { return m_pIUIPanel->GetClasses(); }
+
+	bool BHasClass( const char *pchName ) const { return m_pIUIPanel->BHasClass( pchName ); }
+	bool BHasClass( CPanoramaSymbol symName ) const { return m_pIUIPanel->BHasClass( symName ); }
+	bool BAscendantHasClass( const char *pchName ) const { return m_pIUIPanel->BAscendantHasClass( pchName ); }
+	bool BAscendantHasClass( CPanoramaSymbol symName ) const { return m_pIUIPanel->BAscendantHasClass( symName ); }
+	void ToggleClass( const char *pchName ) { m_pIUIPanel->ToggleClass( pchName ); }
+	void ToggleClass( CPanoramaSymbol symName ) { m_pIUIPanel->ToggleClass( symName ); }
+	void SetHasClass( const char *pchName, bool bHasClass ) { m_pIUIPanel->SetHasClass( pchName, bHasClass ); }
+	void SetHasClass( CPanoramaSymbol symName, bool bHasClass ) { m_pIUIPanel->SetHasClass( symName, bHasClass ); }
+	void SwitchClass( const char *pchAttribute, const char *pchName ) { m_pIUIPanel->SwitchClass( pchAttribute, pchName ); }
+	void SwitchClass( const char *pchAttribute, CPanoramaSymbol symName ) { m_pIUIPanel->SwitchClass( pchAttribute, symName ); }
+
+	const char *GetID() const { return m_pIUIPanel->GetID(); }
+	bool BHasID() const { return m_pIUIPanel->GetID()[0] != '0'; }
+
+	void SetTabIndex( float flTabIndex ) { m_pIUIPanel->SetTabIndex( flTabIndex ); }
+	void SetSelectionPosition( float flXPos, float flYPos ) { m_pIUIPanel->SetSelectionPosition( flXPos, flYPos ); }
+	void SetSelectionPositionX( float flXPos ) { m_pIUIPanel->SetSelectionPositionX( flXPos ); }
+	void SetSelectionPositionY( float flYPos ) { m_pIUIPanel->SetSelectionPositionY( flYPos ); }
+
+	float GetSelectionPositionX() const { return m_pIUIPanel->GetSelectionPositionX(); }
+	float GetSelectionPositionY() const { return m_pIUIPanel->GetSelectionPositionY(); }
+	float GetTabIndex() const { return m_pIUIPanel->GetTabIndex(); }
+
+	//
+	// Implementation of functions that panorama calls back on UI control classes
+	//
+
+	// kb/mouse management
+	virtual bool OnKeyDown( const KeyData_t &code ) OVERRIDE;
+	virtual bool OnKeyUp( const KeyData_t & code ) OVERRIDE;
+	virtual bool OnKeyTyped( const KeyData_t &unichar ) OVERRIDE;
+	virtual bool OnGamePadDown( const GamePadData_t &code ) OVERRIDE;
+	virtual bool OnGamePadUp( const GamePadData_t &code ) OVERRIDE;
+	virtual bool OnGamePadAnalog( const GamePadData_t &code ) OVERRIDE;
+	virtual bool OnMouseButtonDown( const MouseData_t &code ) OVERRIDE;
+	virtual bool OnMouseButtonUp( const MouseData_t &code ) OVERRIDE;
+	virtual bool OnMouseButtonDoubleClick( const MouseData_t &code ) OVERRIDE;
+	virtual bool OnMouseButtonTripleClick( const MouseData_t &code ) OVERRIDE;
+	virtual bool OnMouseWheel( const MouseData_t &code ) OVERRIDE;
+	virtual void OnMouseMove( float flMouseX, float flMouseY ) OVERRIDE;
+	virtual bool OnClick( IUIPanel *pPanel, const MouseData_t &code ) OVERRIDE;
+
+	// events
+	bool OnScrollDirection( IUIScrollBar *pScrollBar, bool bIncreasePosition, float flDelta );
+	bool OnScrollUp();
+	bool OnScrollDown();
+	bool OnScrollLeft();
+	bool OnScrollRight();
+
+	bool OnPageDirection( IUIScrollBar *pScrollBar, bool bIncreasePosition );
+	bool OnPageUp();
+	bool OnPageDown();
+	bool OnPageLeft();
+	bool OnPageRight();
+
+	// Scrolling
+	void ScrollVertically( float flScrollDelta, bool bImmediateMove = false );
+	void ScrollHorizontally( float flScrollDelta, bool bImmediateMove = false );
+	void ScrollToShowVerticalRange( float flRangeStart, float flRangeEnd );
+	virtual void ScrollToXPercent( float flXPercent );
+	virtual void ScrollToYPercent( float flXPercent );
+
+	// navigation events, override these in children if you want special navigation handling,
+	// shouldn't be needed often though, use tabindex/selectionpos in xml layout files!
+	virtual bool OnMoveUp( int nRepeats );
+	virtual bool OnMoveDown( int nRepeats );
+	virtual bool OnMoveLeft( int nRepeats );
+	virtual bool OnMoveRight( int nRepeats );
+	virtual bool OnTabForward( int nRepeats );
+	virtual bool OnTabBackward( int nRepeats );
+
+
+	// child iteration
+	int GetChildCount() const { return m_pIUIPanel->GetChildCount(); }
+	CPanel2D *GetChild( int i ) const { return ToPanel2D( m_pIUIPanel->GetChild( i ) ); }
+	CPanel2D *GetFirstChild() const { return ToPanel2D( m_pIUIPanel->GetFirstChild() ); }
+	CPanel2D *GetLastChild() const { return ToPanel2D( m_pIUIPanel->GetLastChild() ); }
+	// Return index of child in creation/panel vector order (also default tab order)
+	int GetChildIndex( const CPanel2D *pChild ) const { if( !pChild ) return -1; else return m_pIUIPanel->GetChildIndex( pChild->UIPanel() ); }
+
+	int GetHiddenChildCount() const { return m_pIUIPanel->GetHiddenChildCount(); }
+	CPanel2D *GetHiddenChild( int i ) const { return ToPanel2D( m_pIUIPanel->GetHiddenChild( i ) ); }
+
+	// Gets immediate ancestor of this panel in panel hierarchy
+	CPanel2D *GetParent() const { return ToPanel2D( m_pIUIPanel->GetParent() ); }
+	
+	// searches only immediate children
+	CPanel2D *FindChild( const char *pchID ) { return ToPanel2D( m_pIUIPanel->FindChild( pchID ) ); }
+
+	// searches all children even outside layout file scope
+	CPanel2D *FindChildTraverse( const char *pchID ) { return ToPanel2D( m_pIUIPanel->FindChildTraverse( pchID ) ); }
+
+	// searches any children created from our layout file
+	CPanel2D *FindChildInLayoutFile( const char *pchID ) { return ToPanel2D( m_pIUIPanel->FindChildInLayoutFile( pchID ) ); }
+
+	// searches any panel created from our layout file (so parents or children!)
+	CPanel2D *FindPanelInLayoutFile( const char *pchID ) { return ToPanel2D( m_pIUIPanel->FindPanelInLayoutFile( pchID ) ); }
+
+	void MoveChildAfter( CPanel2D *pChildToMove, CPanel2D *pBefore ) { return m_pIUIPanel->MoveChildAfter( pChildToMove->UIPanel(), pBefore->UIPanel() ); }
+	void MoveChildBefore( CPanel2D *pChildToMove, CPanel2D *pAfter ) { return m_pIUIPanel->MoveChildBefore( pChildToMove->UIPanel(), pAfter->UIPanel() ); }
+
+	// window management
+	IUIWindow *GetParentWindow() const { return m_pIUIPanel->GetParentWindow(); }
+
+
+	// input & focus
+	bool BAcceptsInput() { return m_pIUIPanel->BAcceptsInput();  }
+	void SetAcceptsInput( bool bAllowInput ) { m_pIUIPanel->SetAcceptsInput( bAllowInput );  }
+	bool BAcceptsFocus() const { return m_pIUIPanel->BAcceptsFocus(); }
+	void SetAcceptsFocus( bool bAllowFocus ) { m_pIUIPanel->SetAcceptsFocus( bAllowFocus ); }
+	bool BCanAcceptInput() { return m_pIUIPanel->BCanAcceptInput(); }
+	void SetDefaultFocus( const char *pchChildID ) { m_pIUIPanel->SetDefaultFocus( pchChildID ); }
+	const char *GetDefaultFocus() const { return m_pIUIPanel->GetDefaultFocus();  }
+	void SetDisableFocusOnMouseDown( bool bDisable ) { m_pIUIPanel->SetDisableFocusOnMouseDown( bDisable ); }
+	bool BFocusOnMouseDown() { return m_pIUIPanel->BFocusOnMouseDown(); }
+	virtual bool BRequiresFocus() { return false; } // Override if your control requires taking focus in order to operate (e.g. TextEntry)
+
+	// Should this panel be the top of an input hierarchy and keep track of focus within itself, not losing focus when a panel in some
+	// other hierarchy changes focus?  Use this for panels that are peers like friends vs browser vs mainmenu in tenfoot
+	bool BTopOfInputContext() {	return m_pIUIPanel->BTopOfInputContext(); }
+	void SetTopOfInputContext( bool bIsTopOfInputContext ) { return m_pIUIPanel->SetTopOfInputContext( bIsTopOfInputContext ); }
+
+	CPanel2D *GetParentInputContext() { return ToPanel2D( m_pIUIPanel->GetParentInputContext() ); }
+
+	// Get the default input focus child within this panel, may be null
+	CPanel2D *GetDefaultInputFocus() { return ToPanel2D( m_pIUIPanel->GetDefaultInputFocus() ); }
+
+	// Override behavior for getting default input focus, callback from framework
+	virtual IUIPanel *OnGetDefaultInputFocus() OVERRIDE { return NULL;  }
+
+	// Set focus to this panel, which will auto-scroll it into full view as well if parent has overflow: scroll
+	bool SetFocus() { return m_pIUIPanel->SetFocus(); }
+
+	// Set the focus to this panel in it's input context, but do not make the context change if some other context currently
+	// has focus
+	bool UpdateFocusInContext() { return m_pIUIPanel->UpdateFocusInContext(); }
+
+	// Set the focus in response to receiving hover (on panels that a parent sets childfocusonhover), this will
+	// never scroll the parent.
+	bool SetFocusDueToHover() { return m_pIUIPanel->SetFocusDueToHover(); }
+
+	void SetInputContextFocus() { m_pIUIPanel->SetInputContextFocus(); }
+
+	// retrieve the style flags (map to CSS psuedo-classes) for this panel
+	uint GetStyleFlags() const { return m_pIUIPanel->GetStyleFlags(); }
+	void AddStyleFlag( EStyleFlags eStyleFlag ) { m_pIUIPanel->AddStyleFlag( eStyleFlag ); }
+	void RemoveStyleFlag( EStyleFlags eStyleFlag ) { m_pIUIPanel->RemoveStyleFlag( eStyleFlag ); }
+	bool IsInspected() const { return m_pIUIPanel->IsInspected(); }
+	bool BHasHoverStyle() const { return m_pIUIPanel->BHasHoverStyle(); }
+	void SetSelected( bool bSelected ) { m_pIUIPanel->SetSelected( bSelected ); }
+	bool IsSelected() const { return m_pIUIPanel->IsSelected(); }
+	bool BHasKeyFocus() const { return m_pIUIPanel->BHasKeyFocus(); }
+	bool BHasDescendantKeyFocus() const { return m_pIUIPanel->BHasDescendantKeyFocus(); }
+	bool IsLayoutLoading() const { return m_pIUIPanel->IsLayoutLoading(); }
+
+	// enable/disable
+	void SetEnabled( bool bEnabled ) { m_pIUIPanel->SetEnabled( bEnabled ); }
+	bool IsEnabled() const { return m_pIUIPanel->IsEnabled(); }
+
+	bool IsActivationEnabled() { return m_pIUIPanel->IsActivationEnabled(); }
+
+	// Set activation disabled on this panel, input/focus still generally work, but Activate events won't be handled, useful to prevent a button
+	// being clicked when out of focus, but leave it able to be focused for later activation or such
+	void SetActivationEnabled( bool bEnabled ) { m_pIUIPanel->SetActivationEnabled( bEnabled ); }
+
+	// Set all our immediate children enabled/disabled
+	void SetAllChildrenActivationEnabled( bool bEnabled ) { m_pIUIPanel->SetAllChildrenActivationEnabled( bEnabled ); }
+
+	// Enable/disable hit testing of this panel, you may want a parent that is never hit test that has a large region, but clicks
+	// just pass through to other things behind it.  Children may still hit test.
+	void SetHitTestEnabled( bool bEnabled ) { m_pIUIPanel->SetHitTestEnabled( bEnabled ); }
+	bool BHitTestEnabled() const { return m_pIUIPanel->BHitTestEnabled(); }
+	void SetHitTestEnabledTraverse( bool bEnabled ) { m_pIUIPanel->SetHitTestEnabledTraverse( bEnabled ); }
+
+	void SetOnActivateEvent( IUIEvent *pEvent );
+	void SetOnActivateEvent( const char *pchEventString );
+	void SetOnFocusEvent( IUIEvent *pEvent );
+	void SetOnCancelEvent( IUIEvent *pEvent );
+	void SetOnContextMenuEvent( IUIEvent *pEvent );
+	void SetOnLoadEvent( IUIEvent *pEvent );
+	void SetOnMouseActivateEvent( IUIEvent *pEvent );
+	void SetOnMouseOverEvent( IUIEvent *pEvent );
+	void SetOnMouseOutEvent( IUIEvent *pEvent );
+	void SetOnDblClickEvent( IUIEvent *pEvent );
+	void SetOnTabForwardEvent( IUIEvent *pEvent );
+	void SetOnTabBackwardEvent( IUIEvent *pEvent );
+
+	// bugbug jmccaskey - DELETE ME	
+	// bugbug jmccaskey - both of the next two functions need to be deleted, we should
+	// not expose panel event internals like this, but parental button needs some refactoring
+	// first.  That refactoring must happen to work at all with javascript panel events anyway.
+	VecUIEvents_t * GetPanelEvents( CPanoramaSymbol symEvent ) { return m_pIUIPanel->GetPanelEvents( symEvent ); }
+	virtual void OnPanelEventSet( CPanoramaSymbol symEvent ) OVERRIDE { }
+
+	bool BHasOnActivateEvent() { return m_pIUIPanel->BHasOnActivateEvent(); }
+	bool BHasOnMouseActivateEvent() { return m_pIUIPanel->BHasOnMouseActivateEvent(); }
+
+	void ClearOnActivateEvent();
+
+	// Dialog variables
+	void SetDialogVariable( const char *pchKey, const char *pchValue );
+	void SetDialogVariable( const char *pchKey, int iVal );
+	// We do NOT have a uint32 type here by design, to prevent you accidenatlly using a RTime32
+	// and getting a number value. Either cast to int for a number or construct a CRTime
+#if defined (SOURCE2_PANORAMA )
+	void SetDialogVariable( const char *pchKey, time_t timeVal );
+	void SetDialogVariable( const char *pchKey, CCurrencyAmount amount );
+#else
+	void SetDialogVariable( const char *pchKey, CAmount amount );
+	void SetDialogVariable( const char *pchKey, CRTime timeVal );
+#endif
+	void SetDialogVariable( const char *varName, const CUtlString &value );
+	void SetDialogVariableLocString( const char *varName, const char *pchValue );
+
+
+
+	// Scrolling controls
+	void ScrollToTop() { m_pIUIPanel->ScrollToTop(); }
+	void ScrollToBottom() { m_pIUIPanel->ScrollToBottom(); }
+	void ScrollToLeftEdge() { m_pIUIPanel->ScrollToLeftEdge(); }
+	void ScrollToRightEdge() { m_pIUIPanel->ScrollToRightEdge(); }
+	void ScrollParentToMakePanelFit( ScrollBehavior_t behavior = SCROLL_BEHAVIOR_DEFAULT, bool bImmediateScroll = false ) { m_pIUIPanel->ScrollParentToMakePanelFit( behavior, bImmediateScroll ); }
+	void ScrollToFitRegion( float x0, float x1, float y0, float y1, ScrollBehavior_t behavior = SCROLL_BEHAVIOR_DEFAULT, bool bDirectParentScrollOnly = false, bool bImmediateScroll = false ) { m_pIUIPanel->ScrollToFitRegion( x0, x1, y0, y1, behavior, bDirectParentScrollOnly, bImmediateScroll ); }
+	bool BCanSeeInParentScroll() { return m_pIUIPanel->BCanSeeInParentScroll(); }
+	
+	void OnScrollPositionChanged() { m_pIUIPanel->OnScrollPositionChanged(); }
+	void SetSendChildScrolledIntoViewEvents( bool bSendChildScrolledIntoViewEvents ) { m_pIUIPanel->SetSendChildScrolledIntoViewEvents( bSendChildScrolledIntoViewEvents ); }	// this must be enabled on your parent for ScrolledIntoView events to fire and IsScrolledIntoView state to be set
+	void FireScrolledIntoViewEvent() { m_pIUIPanel->FireScrolledIntoViewEvent(); }
+	void FireScrolledOutOfViewEvent() { m_pIUIPanel->FireScrolledOutOfViewEvent(); }
+	bool IsScrolledIntoView() const { return m_pIUIPanel->IsScrolledIntoView(); }
+
+	bool BSelectionPosVerticalBoundary() { return m_pIUIPanel->BSelectionPosVerticalBoundary(); }
+	bool BSelectionPosHorizontalBoundary() { return m_pIUIPanel->BSelectionPosHorizontalBoundary(); }
+
+	// Tell panel to set focus to next panel in specified movement direction/type
+	bool SetFocusToNextPanel( int nRepeats, EFocusMoveDirection moveType, bool bAllowWrap, float flTabIndexCurrent, float flXPosCurrent, float flYPosCurrent, float flXStart, float flYStart ) { return m_pIUIPanel->SetFocusToNextPanel( nRepeats, moveType, bAllowWrap, flTabIndexCurrent, flXPosCurrent, flYPosCurrent, flXStart, flYStart ); }
+	virtual bool OnSetFocusToNextPanel( int nRepeats, EFocusMoveDirection moveType, bool bAllowWrap, float flTabIndexCurrent, float flXPosCurrent, float flYPosCurrent, float flXStart, float flYStart ) OVERRIDE{ return false; }
+	bool SetInputFocusToFirstOrLastChildInFocusOrder( EFocusMoveDirection moveType, float flXStart, float flYStart ) { return m_pIUIPanel->SetInputFocusToFirstOrLastChildInFocusOrder( moveType, flXStart, flYStart ); }
+
+	// hierarchy
+	void SetParent( CPanel2D *pParent ) { m_pIUIPanel->SetParent( pParent ? pParent->UIPanel() : NULL ); }
+	void RemoveAndDeleteChildren() { m_pIUIPanel->RemoveAndDeleteChildren(); }
+	void RemoveAndDeleteChildrenOfType( CPanoramaSymbol symPanelType ) { m_pIUIPanel->RemoveAndDeleteChildrenOfType( symPanelType ); }
+	uint32 GetChildCountOfType( CPanoramaSymbol symPanelType ) { return m_pIUIPanel->GetChildCountOfType( symPanelType ); }
+	bool IsDescendantOf( const CPanel2D *pPanel ) const { return m_pIUIPanel->IsDescendantOf( pPanel ? pPanel->m_pIUIPanel : NULL ); }
+	CPanel2D *FindAncestor( const char *pchID ) { return ToPanel2D( m_pIUIPanel->FindAncestor( pchID ) );  }
+
+	// layout file
+	CPanoramaSymbol GetLayoutFileLoadedFrom() const { return m_pIUIPanel->GetLayoutFileLoadedFrom(); }
+
+	// Override this and return true if you know your panel will never draw outside it's bounds,
+	// thus allowing an optimization to skip pushing clipping layers.
+	virtual bool BRequiresContentClipLayer() OVERRIDE { return false; }
+
+	// debug
+	virtual void GetDebugPropertyInfo( CUtlVector< DebugPropertyOutput_t *> *pvecProperties );
+
+	void SetTooltip( CPanel2D *pPanel );
+
+	// Panel events
+	bool DispatchPanelEvent( CPanoramaSymbol symPanelEvent ) { return m_pIUIPanel->DispatchPanelEvent( symPanelEvent ); }
+	bool BParsePanelEvent( CPanoramaSymbol symPanelEvent, const char *pchValue ) { return m_pIUIPanel->BParsePanelEvent( symPanelEvent, pchValue ); }
+	bool BIsPanelEventSet( CPanoramaSymbol symPanelEvent ) { return m_pIUIPanel->BIsPanelEventSet( symPanelEvent ); }
+	bool BIsPanelEvent( CPanoramaSymbol symProperty ) { return m_pIUIPanel->BIsPanelEvent( symProperty ); }
+
+	// the input namespace to use for this panel
+	const char *GetInputNamespace() const {	return m_pIUIPanel->GetInputNamespace(); }
+
+	// the mouse cursor to display when hovered
+	virtual EMouseCursors GetMouseCursor() OVERRIDE { return eMouseCursor_Arrow; }
+
+	// controls if clicking on an unfocused panel should set focus
+	void SetMouseCanActivate( EMouseCanActivate eMouseCanActivate, const char *pchOptionalParent = NULL ) { m_pIUIPanel->SetMouseCanActivate( eMouseCanActivate, pchOptionalParent ); }
+	EMouseCanActivate GetMouseCanActivate() { return m_pIUIPanel->GetMouseCanActivate(); }
+	CPanel2D *FindParentForMouseCanActivate() { return ToPanel2D( m_pIUIPanel->FindParentForMouseCanActivate() ); }
+
+	// controls if clicking on an unfocused panel should set focus
+	void SetChildFocusOnHover( bool bEnable ) { m_pIUIPanel->SetChildFocusOnHover( bEnable ); }
+	bool GetChildFocusOnHover() { return m_pIUIPanel->GetChildFocusOnHover(); }
+
+	// Set background images for the panel
+	void SetBackgroundImages( const CUtlVector< CBackgroundImageLayer * > &vecLayers );
+	CUtlVector< CBackgroundImageLayer * > *GetBackgroundImages();
+
+	// called once after registering with UIEngine::CallBeforeStyleAndLayout()
+	virtual void OnCallBeforeStyleAndLayout() OVERRIDE {}
+
+	// clone
+	virtual bool IsClonable();
+	virtual CPanel2D *Clone();
+
+	// sort children
+	void SortChildren( int( __cdecl *pfnCompare )(const ClientPanelPtr_t *, const ClientPanelPtr_t *) ) { m_pIUIPanel->SortChildren( pfnCompare ); }
+
+	// set the namespace to use for input
+	void SetInputNamespace( const char *pchNamespace ) { m_pIUIPanel->SetInputNamespace( pchNamespace ); }
+
+	// override this if you need to have the loc system consider an alternate panel hierarchy for resolving dialog variables
+	virtual IUIPanel *GetLocalizationParent() const OVERRIDE { return GetParent() ? GetParent()->m_pIUIPanel : NULL; }
+
+	// child management, use with caution! normally always managed internally.
+	void AddChild( CPanel2D *pChild ) { m_pIUIPanel->AddChild( pChild->UIPanel() ); }
+
+	// child management, use with caution! normally always managed internally.  Returns child index we inserted at.
+	int AddChildSorted( bool( __cdecl *pfnLessFunc )(ClientPanelPtr_t const &p1, ClientPanelPtr_t const &p2), CPanel2D *pChild ) { return m_pIUIPanel->AddChildSorted( pfnLessFunc, pChild->UIPanel() ); }
+
+	// child management, use with caution! normally always managed internally.
+	void RemoveChild( CPanel2D *pChild ) { m_pIUIPanel->RemoveChild( pChild->UIPanel() ); }
+
+	// Check if styles are dirty for the panel
+	bool BStylesDirty() const { return m_pIUIPanel->BStylesDirty(); }
+	
+	// Check if styles are possibly dirty for any of our children
+	bool BChildStylesDirty() { return m_pIUIPanel->BChildStylesDirty(); }
+
+	// Set that we need an on styles changed call when styles become non-dirty, even if there is no actual change.
+	void SetOnStylesChangedNeeded() { m_pIUIPanel->SetOnStylesChangedNeeded(); }
+
+
+	// Getter for panel attributes
+	int GetAttribute( const char *pchAttrName, int nDefaultValue ) { return m_pIUIPanel->GetAttribute( pchAttrName, nDefaultValue ); }
+
+	// Getter for panel attributes
+	const char *GetAttribute( const char *pchAttrName, const char * pchDefaultValue ) { return m_pIUIPanel->GetAttribute( pchAttrName, pchDefaultValue ); }
+
+	// Getter for panel attributes
+	uint32 GetAttribute( const char *pchAttrName, uint32 unDefaultValue ) { return m_pIUIPanel->GetAttribute( pchAttrName, unDefaultValue ); }
+
+	// Getter for panel attributes
+	uint64 GetAttribute( const char *pchAttrName, uint64 unDefaultValue ) { return m_pIUIPanel->GetAttribute( pchAttrName, unDefaultValue ); }
+
+	// Setter for panel attributes
+	void SetAttribute( const char *pchAttrName, int nValue ) { m_pIUIPanel->SetAttribute( pchAttrName, nValue ); }
+
+	// Setter for panel attributes
+	void SetAttribute( const char *pchAttrName, const char * pchValue ) { m_pIUIPanel->SetAttribute( pchAttrName, pchValue ); }
+
+	// Setter for panel attributes
+	void SetAttribute( const char *pchAttrName, uint32 unValue ) { m_pIUIPanel->SetAttribute( pchAttrName, unValue ); }
+
+	// Setter for panel attributes
+	void SetAttribute( const char *pchAttrName, uint64 unValue ) { m_pIUIPanel->SetAttribute( pchAttrName, unValue ); }
+
+	// walks parents calculating the top left corner relative to window space
+	void GetPositionWithinWindow( float *pflX, float *pflY );
+
+	// walks parents calculating the top left corner relative to the ancestor's space. If
+	// the passed in panel is NULL or not an ancestor, this will end up being relative to the window space 
+	virtual void GetPositionWithinAncestor( CPanel2D *pAncestor, float *pflX, float *pflY ) OVERRIDE;
+
+	bool BHasAnyActiveTransitions();
+
+	// Get the nearest parent that establishes a javascript context, or return ourself if we ourselves create one
+	panorama::CPanel2D *GetJavaScriptContextParent() const { return (CPanel2D*)(m_pIUIPanel->GetJavaScriptContextParent()->ClientPtr()); }
+
+	// Called to ask us to setup object template for Javascript, you can implement this in a child class and then call
+	// the base method (so all the normal panel2d stuff gets exposed), plus call the various RegisterJS helpers yourself
+	// to expose additional panel type specific data/methods.
+	virtual void SetupJavascriptObjectTemplate() OVERRIDE;
+
+	// Callback to client panel to create a scrollbar
+	virtual IUIScrollBar *CreateNewVerticalScrollBar( float flInitialScrollPos ) OVERRIDE;
+
+	// Callback to client panel to create a scrollbar
+	virtual IUIScrollBar *CreateNewHorizontalScrollBar( float flInitialScrollPos ) OVERRIDE;
+
+	// Callback to hide tooltip if it's visible
+	virtual void HideTooltip() OVERRIDE;
+
+	// Has this panel ever been layed out
+	virtual bool BHasBeenLayedOut() const { return m_pIUIPanel->BHasBeenLayedOut(); }
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
+	void Validate( CValidator &validator, const tchar *pchName );
+	static void ValidateStatics( CValidator &validator, const char *pchName );
+#endif
+
+	void SetLayoutLoadedFromParent( CPanel2D *pParent ) { m_pIUIPanel->SetLayoutLoadedFromParent( pParent ? pParent->UIPanel() : NULL ); }
+
+	IUIImageManager *UIImageManager() { return m_pIUIPanel->UIImageManager(); }
+
+protected:
+	friend class CPanelStyle;
+	friend class CStyleFileSet;
+	friend class CVerticalScrollBar;
+	friend class CHorizontalScrollBar;
+
+	virtual IUIRenderEngine *AccessRenderEngine() { return m_pIUIPanel->GetParentWindow()->UIRenderEngine(); }
+
+	void FirePanelLoadedEvent() { m_pIUIPanel->FirePanelLoadedEvent();  }
+
+	// override to change how this panel is measured
+	virtual void OnContentSizeTraverse( float *pflContentWidth, float *pflContentHeight, float flMaxWidth, float flMaxHeight, bool bFinalDimensions ) OVERRIDE
+	{ 
+		m_pIUIPanel->OnContentSizeTraverse( pflContentWidth, pflContentHeight, flMaxWidth, flMaxHeight, bFinalDimensions );  
+	}
+
+	// override to add additional panel events
+	virtual bool BIsClientPanelEvent( CPanoramaSymbol symProperty ) OVERRIDE;
+
+	// override to change how this panel arranges its children
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight ) OVERRIDE { m_pIUIPanel->OnLayoutTraverse( flFinalWidth, flFinalHeight ); }
+	
+	virtual void OnStylesChanged() OVERRIDE { if ( m_pIUIPanel->GetParent() ) { m_pIUIPanel->GetParent()->ClientPtr()->OnChildStylesChanged(); } }
+	virtual void OnVisibilityChanged() OVERRIDE {}
+
+	virtual void OnChildStylesChanged() OVERRIDE { }
+
+	// methods for setting properties from a layout file. Default BSetProperties calls BSetProperty on each element.
+	virtual bool BSetProperties( const CUtlVector< ParsedPanelProperty_t > &vecProperties ) OVERRIDE;
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+
+
+	virtual void OnBeforeChildrenChanged() OVERRIDE {}
+	virtual void OnAfterChildrenChanged() OVERRIDE {}
+	virtual void OnRemoveChild( IUIPanel *pChild ) OVERRIDE {}
+
+	virtual void OnInitializedFromLayout() OVERRIDE {}
+
+	void SetLayoutFile( CPanoramaSymbol symLayoutFile ) { m_pIUIPanel->SetLayoutFile( symLayoutFile ); }
+	void SetLayoutFileTraverse( CPanoramaSymbol symLayoutFile );
+
+	void SetMouseTracking( bool bState ) { m_pIUIPanel->SetMouseTracking( bState ); }
+	
+	// for cloning
+	bool AreChildrenClonable();
+	virtual void InitClonedPanel( CPanel2D *pPanel );
+
+	// for setting parent disabled style flag	
+	//bugbug jmccaskey - these are broken... would like to fix so they are uneeded
+	virtual void AddDisabledFlagToChildren() { }
+	virtual void RemoveDisabledFlagFromChildren() { }
+
+	// Pointer to basic IUIPanel interface from panorama
+	IUIPanel *m_pIUIPanel;
+
+private:
+	// we by design don't have a uint32 overload of this, use this function here to enforce it
+	void SetDialogVariable( const char *pchKey, uint32 nInvalid ) { Assert( !"Invalid call" ); }
+
+	CUtlVector<IUIPanel *> const &AccessChildren() { return m_pIUIPanel->AccessChildren(); }
+	CUtlVector<IUIPanel *> const &JSFindChildrenWithClassTraverse( const char *pchClass );
+
+	
+	// event handler functions, these CANNOT be virtual, if you need to override then
+	// have this function call into another helper that is virtual to override behavior
+	bool EventAppendChildrenFromLayoutFileAsync( const CPanelPtr< IUIPanel > &pPanel, const char *pchLayoutFile );
+	bool EventAddStyleClass( const CPanelPtr< IUIPanel > &pPanel, const char *pchName );
+	bool EventRemoveStyleClass( const CPanelPtr< IUIPanel > &pPanel, const char *pchName );
+	bool EventToggleStyleClass( const CPanelPtr< IUIPanel > &pPanel, const char *pchName );
+	bool EventAddStyleClassToEachChild( const CPanelPtr< IUIPanel > &pPanel, const char *pchName );
+	bool EventRemoveStyleClassFromEachChild( const CPanelPtr< IUIPanel > &pPanel, const char *pchName );
+	bool EventPanelActivated( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+	bool EventPanelCancelled( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+	bool EventPanelContextMenu( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+	bool EventPanelLoaded( const CPanelPtr< IUIPanel > &pPanel );
+	bool EventShowTooltip( const CPanelPtr< IUIPanel > &pPanel );
+	bool EventScrollUp()		{ return OnScrollUp(); }
+	bool EventScrollDown()		{ return OnScrollDown(); }
+	bool EventScrollLeft()		{ return OnScrollLeft(); }
+	bool EventScrollRight()		{ return OnScrollRight(); }
+	bool EventScrollPanelUp( const CPanelPtr< IUIPanel > &pPanel )		{ return OnScrollUp(); }
+	bool EventScrollPanelDown( const CPanelPtr< IUIPanel > &pPanel )	{ return OnScrollDown(); }
+	bool EventScrollPanelLeft( const CPanelPtr< IUIPanel > &pPanel )	{ return OnScrollLeft(); }
+	bool EventScrollPanelRight( const CPanelPtr< IUIPanel > &pPanel )	{ return OnScrollRight(); }
+	bool EventPageUp()			{ return OnPageUp(); }
+	bool EventPageDown()		{ return OnPageDown(); }
+	bool EventPageLeft()		{ return OnPageLeft(); }
+	bool EventPageRight()		{ return OnPageRight(); }
+	bool EventPagePanelUp( const CPanelPtr< IUIPanel > &pPanel )	{ return OnPageUp(); }
+	bool EventPagePanelDown( const CPanelPtr< IUIPanel > &pPanel )	{ return OnPageDown(); }
+	bool EventPagePanelLeft( const CPanelPtr< IUIPanel > &pPanel )	{ return OnPageLeft(); }
+	bool EventPagePanelRight( const CPanelPtr< IUIPanel > &pPanel )	{ return OnPageRight(); }
+	bool EventScrollToTop( const CPanelPtr< IUIPanel > &pPanel );
+	bool EventScrollToBottom( const CPanelPtr< IUIPanel > &pPanel );
+	bool EventMoveUp( int nRepeats )			{ return OnMoveUp( nRepeats ); }
+	bool EventMoveDown( int nRepeats )		{ return OnMoveDown( nRepeats ); } 
+	bool EventMoveLeft( int nRepeats )		{ return OnMoveLeft( nRepeats ); }
+	bool EventMoveRight( int nRepeats )		{ return OnMoveRight( nRepeats ); }
+	bool EventTabForward( int nRepeats )		{ return OnTabForward( nRepeats ); }
+	bool EventTabBackward( int nRepeats )		{ return OnTabBackward( nRepeats ); }	
+	bool EventImageLoaded( const CPanelPtr< IUIPanel > &pPanel, IImageSource *pImage );
+	bool EventImageFailedLoad( const CPanelPtr< IUIPanel > &pPanel, IImageSource *pImage );
+	bool EventSetPanelEvent( const CPanelPtr< IUIPanel > &pPanel, const char *pchPanelEventName, const char *pchPanelEventAction );
+	bool EventClearPanelEvent( const CPanelPtr< IUIPanel > &pPanel, const char *pchPanelEventName );
+	bool EventIfHasClassEvent( const CPanelPtr< IUIPanel > &pPanel, const char * pchClassName, IUIEvent * pEventToFire );
+	bool EventIfNotHasClassEvent( const CPanelPtr< IUIPanel > &pPanel, const char * pchClassName, IUIEvent * pEventToFire );
+	bool EventIfHoverOtherEvent( const CPanelPtr< IUIPanel > &pPanel, const char *pchOtherPanelID, IUIEvent * pEventToFire );
+	bool EventIfNotHoverOtherEvent( const CPanelPtr< IUIPanel > &pPanel, const char *pchOtherPanelID, IUIEvent * pEventToFire );
+	bool EventIfHoverOverEventInternal( const CPanelPtr< IUIPanel > &pPanel, const char *pchOtherPanelID, IUIEvent * pEventToFire, bool bFireIfHovered );
+	bool EventCheckChildrenScrolledIntoView( const CPanelPtr< IUIPanel > &pPanel ) { return m_pIUIPanel->OnCheckChildrenScrolledIntoView(); }
+	bool EventScrollPanelIntoView( const CPanelPtr< IUIPanel > &pPanel, ScrollBehavior_t behavior, bool bImmediate );
+
+	void Initialize( IUIWindow *window, CPanel2D *parent, const char *pchID, uint32 ePanelFlags );
+	bool BAppyLayoutFile( CLayoutFile *pLayoutFile, CUtlVector< CPanel2D * > *pvecExistingPanels );
+	void DeletePanelsForReloadTraverse( CPanoramaSymbol symPath, CUtlVector< CPanel2D * > *pvecPanelsWithID );
+	
+	// Is this a property we must create our children before applying during layout file application?
+	virtual bool BIsDelayedProperty( CPanoramaSymbol symProperty ) OVERRIDE;
+
+	void ClearPanelEventJS( CPanoramaSymbol symPanelEvent ) { m_pIUIPanel->ClearPanelEvents( symPanelEvent ); }
+
+	// Private helper for JS attribute registration
+	void RegisterJSFloatTabIndexSelectionPos( const char *pchjsMemberName, PanelFloatGetter_t pGetFunc, PanelFloatSetter_t pSetFunc );
+
+	void SetDefaultFocusOnMouseDownBehavior();
+
+	// tooltip for panel. Need to keep a safe pointer as the tooltip is a top level window and will be deleted at shutdown automatically
+	CPanelPtr< CPanel2D > m_pTooltip;
+
+	static CUtlVector<IUIPanel *> s_vecMatchingChildren;
+};
+
+
+class CUIScrollBar;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Base class for all types of scroll bars
+//-----------------------------------------------------------------------------
+class CBaseScrollBar : public CPanel2D
+{
+	DECLARE_PANEL2D( CBaseScrollBar, CPanel2D );
+
+public:
+	CBaseScrollBar( CPanel2D *parent, const char * pchPanelID );
+
+	virtual ~CBaseScrollBar();
+
+	IUIScrollBar *Interface();
+
+	// Normalizes the position to be within range min/max 
+	void Normalize( bool bImmediateThumbUpdate = false )
+	{
+		if ( m_flWindowStart < m_flRangeMin )
+			m_flWindowStart = m_flRangeMin;
+
+		if ( m_flWindowStart + m_flWindowSize > m_flRangeMax )
+		{
+			m_flWindowStart = m_flRangeMax - m_flWindowSize;
+			m_flWindowStart = RoundFloatToInt( m_flWindowStart );
+		}
+		else
+		{
+			m_flWindowStart = RoundFloatToInt( m_flWindowStart );
+		}
+
+		UpdateLayout( bImmediateThumbUpdate );
+	}
+
+	// Set the scroll range 
+	void SetRangeMinMax( float flRangeMin, float flRangeMax )
+	{
+		if ( m_flRangeMin != flRangeMin || m_flRangeMax != flRangeMax )
+		{
+			m_flRangeMin = flRangeMin;
+			m_flRangeMax = flRangeMax;
+
+			if ( GetParent() )
+				GetParent()->InvalidatePosition();
+
+			Normalize( false );
+		}
+	}
+
+	// return the size of the range we have
+	float GetRangeSize() const { return m_flRangeMax - m_flRangeMin; }
+	float GetRangeMin() const { return m_flRangeMin; }
+	float GetRangeMax() const { return m_flRangeMax; }
+
+	// Set the window size
+	void SetScrollWindowSize( float flWindowSize )
+	{
+		if ( m_flWindowSize != flWindowSize )
+		{
+			m_flWindowSize = flWindowSize;
+
+			if ( GetParent() )
+				GetParent()->InvalidatePosition();
+
+			Normalize( false );
+		}
+	}
+
+	// Get scroll window size
+	float GetScrollWindowSize() { return m_flWindowSize; }
+
+	// Set the current window position
+	void SetScrollWindowPosition( float flWindowPos, bool bImmediateMove = false )
+	{
+		m_flWindowStart = flWindowPos;
+		m_flLastScrollTime = UIEngine()->GetCurrentFrameTime();
+
+
+		if ( GetParent() )
+		{
+			if ( GetParent()->IsChildPositionValid() && GetParent()->IsPositionValid() )
+				Normalize( bImmediateMove );
+
+			GetParent()->InvalidatePosition();
+			GetParent()->OnScrollPositionChanged();
+		}
+	}
+
+	double GetLastScrollTime() { return m_flLastScrollTime; }
+
+	// Get scroll window position
+	float GetScrollWindowPosition() { return m_flWindowStart; }
+
+	bool BLastMoveImmediate() { return m_bLastMoveImmediate; }
+
+protected:
+
+	friend class CUIScrollBar;
+
+	CUIScrollBar *m_pScrollBarInterface;
+
+	virtual void UpdateLayout( bool bImmediateMove ) = 0;
+
+	bool m_bLastMoveImmediate;
+
+	double m_flLastScrollTime;
+	float m_flRangeMin;
+	float m_flRangeMax;
+	float m_flWindowSize;
+	float m_flWindowStart;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Default Scrollbar
+//-----------------------------------------------------------------------------
+class CScrollBar : public CBaseScrollBar
+{
+	DECLARE_PANEL2D( CScrollBar, CBaseScrollBar );
+
+public:
+	CScrollBar( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CScrollBar();
+
+	virtual void ScrollToMousePos() = 0;
+
+	virtual void OnMouseMove( float flMouseX, float flMouseY )
+	{
+		// If there's a transform set on the parent, adjust the input as appropriate.
+		Vector vMousePosition( flMouseX, flMouseY, 0.0f );
+		if ( GetParent() )
+		{
+			VMatrix matParentTransform = GetParent()->AccessStyle()->GetTransform3DMatrix();
+			vMousePosition = matParentTransform * vMousePosition;
+		}
+
+		m_flMouseX = vMousePosition.x;
+		m_flMouseY = vMousePosition.y;
+
+		if ( m_bMouseDown )
+			ScrollToMousePos();
+	}
+
+	virtual bool OnMouseButtonDown( const MouseData_t &code )
+	{
+		// Only interested in left clicks
+		if ( code.m_MouseCode != MOUSE_LEFT )
+			return BaseClass::OnMouseButtonDown( code );
+
+		AddClass( "MouseDown" );
+		
+		if ( m_pScrollThumb->BHasHoverStyle() )
+			m_bMouseWentDownOnThumb = true;
+		else
+			m_bMouseWentDownOnThumb = false;
+		m_bMouseDown = true;
+		m_flMouseStartX = m_flMouseX;
+		m_flMouseStartY = m_flMouseY;
+		m_flScrollStartPosition = GetScrollWindowPosition();
+		ScrollToMousePos();
+
+		return true;
+	}
+
+	virtual bool OnMouseButtonUp( const MouseData_t &code )
+	{
+		// Only interested in left clicks
+		if ( code.m_MouseCode != MOUSE_LEFT )
+			return BaseClass::OnMouseButtonDown( code );
+
+		m_bMouseDown = false;
+		ScrollToMousePos();
+
+		RemoveClass( "MouseDown" );
+
+		return true;
+	}
+
+protected:
+	CPanel2D *m_pScrollThumb;
+
+	bool m_bMouseDown;
+	bool m_bMouseWentDownOnThumb;
+
+	float m_flMouseX;
+	float m_flMouseY;
+	float m_flMouseStartX;
+	float m_flMouseStartY;
+	float m_flScrollStartPosition;
+};
+
+
+class CUIScrollBar : public IUIScrollBar
+{
+public:
+	CUIScrollBar( CBaseScrollBar *pParent ) { m_pParent = pParent; }
+
+	virtual IUIPanel* UIPanel() OVERRIDE { return m_pParent->UIPanel(); }
+	virtual IUIPanelClient* ClientPtr() OVERRIDE { return m_pParent; }
+
+	virtual void Normalize( bool bImmediateThumbUpdate ) OVERRIDE { return m_pParent->Normalize( bImmediateThumbUpdate ); }
+
+	virtual void SetRangeMinMax( float flRangeMin, float flRangeMax ) OVERRIDE { return m_pParent->SetRangeMinMax( flRangeMin, flRangeMax ); }
+
+	virtual float GetRangeSize() const OVERRIDE { return m_pParent->GetRangeSize(); }
+	virtual float GetRangeMin() const OVERRIDE { return m_pParent->GetRangeMin(); }
+	virtual float GetRangeMax() const OVERRIDE { return m_pParent->GetRangeMax(); }
+
+		// Set the window size
+	virtual void SetScrollWindowSize( float flWindowSize ) OVERRIDE { return m_pParent->SetScrollWindowSize( flWindowSize ); }
+
+		// Get scroll window size
+	virtual float GetScrollWindowSize() OVERRIDE { return m_pParent->GetScrollWindowSize(); }
+
+		// Set the current window position
+	virtual void SetScrollWindowPosition( float flWindowPos, bool bImmediateMove = false ) OVERRIDE { return m_pParent->SetScrollWindowPosition( flWindowPos, bImmediateMove ); }
+
+	virtual float GetLastScrollTime() OVERRIDE { return m_pParent->GetLastScrollTime(); }
+
+	// Get scroll window position
+	virtual float GetScrollWindowPosition() OVERRIDE { return m_pParent->GetScrollWindowPosition(); }
+
+	// Return true if the user is manually dragging the scrollbar with the mouse
+	virtual bool BLastMoveImmediate() OVERRIDE { return m_pParent->BLastMoveImmediate(); }
+
+private:
+	CBaseScrollBar *m_pParent;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Vertical scroll bar
+//-----------------------------------------------------------------------------
+class CVerticalScrollBar : public CScrollBar
+{
+	DECLARE_PANEL2D( CVerticalScrollBar, CScrollBar );
+
+public:
+	CVerticalScrollBar( CPanel2D *parent, const char * pchPanelID ) : CScrollBar( parent, pchPanelID ) 
+	{
+		m_pScrollThumb->AddClass( "VerticalScrollThumb" );
+	}
+	
+	void ScrollToMousePos()
+	{
+		CPanel2D *pPanel = GetParent();
+		if ( pPanel )
+		{
+			float flHeight = GetActualLayoutHeight();
+			if ( flHeight > 0.00001f )
+			{
+				if ( m_bMouseWentDownOnThumb )
+				{
+					float flPercentDiff = (m_flMouseY - m_flMouseStartY) / flHeight;
+					float flPositionOffset = flPercentDiff * pPanel->GetContentHeight();
+					float flPosition = m_flScrollStartPosition + flPositionOffset;
+					SetScrollWindowPosition( clamp( flPosition, 0.0f, pPanel->GetContentHeight() - GetScrollWindowSize() ), true );
+				}
+				else
+				{
+					float flPercent = m_flMouseY / flHeight;
+					float flPos = pPanel->GetContentHeight() * flPercent;
+					SetScrollWindowPosition( clamp( flPos, 0.0f, pPanel->GetContentHeight() - GetScrollWindowSize() ), true );
+				}
+			}
+		}
+	}
+
+
+	virtual ~CVerticalScrollBar() {}
+
+protected:
+	virtual void UpdateLayout( bool bImmediateMove );
+	
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Horizontal scroll bar
+//-----------------------------------------------------------------------------
+class CHorizontalScrollBar : public CScrollBar
+{
+	DECLARE_PANEL2D( CHorizontalScrollBar, CScrollBar );
+
+public:
+	CHorizontalScrollBar( CPanel2D *parent, const char * pchPanelID ) : CScrollBar( parent, pchPanelID ) 
+	{
+		m_pScrollThumb->AddClass( "HorizontalScrollThumb" );
+	}
+
+	void ScrollToMousePos()
+	{
+		CPanel2D *pPanel = GetParent();
+		if ( pPanel )
+		{
+			float flWidth = GetActualLayoutWidth();
+			if ( flWidth > 0.00001f )
+			{
+				if ( m_bMouseWentDownOnThumb )
+				{
+					float flPercentDiff = ( m_flMouseX - m_flMouseStartX ) / flWidth;
+					float flPositionOffset = flPercentDiff * pPanel->GetContentWidth();
+					float flPosition = m_flScrollStartPosition + flPositionOffset;
+					SetScrollWindowPosition( clamp( flPosition, 0.0f, pPanel->GetContentWidth() - GetScrollWindowSize() ), true );
+				}
+				else
+				{
+					float flPercent = m_flMouseX / flWidth;
+					float flPos = pPanel->GetContentWidth() * flPercent;
+					SetScrollWindowPosition( clamp( flPos, 0.0f, pPanel->GetContentWidth() - GetScrollWindowSize() ), true );
+				}
+			}
+		}
+	}
+
+	virtual ~CHorizontalScrollBar() {}
+
+protected:
+
+	virtual void UpdateLayout( bool bImmediateMove );
+};
+
+#pragma warning(pop)
+
+
+} // namespace panorama
+
+#endif // PANEL2D_H
diff --git a/public/panorama/controls/panelhandle.h b/public/panorama/controls/panelhandle.h
new file mode 100644
index 0000000..bbd868b
--- /dev/null
+++ b/public/panorama/controls/panelhandle.h
@@ -0,0 +1,56 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANELHANDLE_H
+#define PANELHANDLE_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tier0/platform.h"
+
+namespace panorama
+{
+
+const uint64 k_ulInvalidPanelHandle64 = 0x00000000FFFFFFFF;
+
+//
+// Safe handle to a panel. To get pointer to actual panel, call IUIEngine::GetPanelPtr
+//
+struct PanelHandle_t
+{
+	int32 m_iPanelIndex;			// index into panel map
+	uint32 m_unSerialNumber;		// unique number used to ensure that panel at m_iPanelIndex is still the panel we originally pointed to
+
+	bool operator<( const PanelHandle_t &rhs ) const
+	{
+		if ( m_iPanelIndex != rhs.m_iPanelIndex )
+			return m_iPanelIndex < rhs.m_iPanelIndex;
+
+		return m_unSerialNumber < rhs.m_unSerialNumber;
+	}
+
+	bool operator==( const PanelHandle_t &rhs ) const
+	{
+		return (m_iPanelIndex == rhs.m_iPanelIndex) && (m_unSerialNumber == rhs.m_unSerialNumber);
+	}
+
+	bool operator!=( const PanelHandle_t &rhs ) const
+	{
+		return !(*this == rhs);
+	}
+
+
+	static const PanelHandle_t &InvalidHandle()
+	{
+		static PanelHandle_t s_invalid = { k_ulInvalidPanelHandle64 >> 32, 0xffffffff & k_ulInvalidPanelHandle64 };
+		return s_invalid;
+	}
+};
+
+} // namespace panorama
+
+#endif // PANELHANDLE_H
diff --git a/public/panorama/controls/panelptr.h b/public/panorama/controls/panelptr.h
new file mode 100644
index 0000000..79a1838
--- /dev/null
+++ b/public/panorama/controls/panelptr.h
@@ -0,0 +1,153 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANELPTR_H
+#define PANELPTR_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panelhandle.h"
+#include "../iuiengine.h"
+#include "../iuipanelclient.h"
+#include "panorama/panoramacxx.h"
+#include "generichash.h"
+
+namespace panorama
+{
+
+class CPanel2D;
+
+//
+// Safe pointer to a panel
+//
+template < class T >
+class CPanelPtr
+{
+public:
+	CPanelPtr() { Clear(); }
+	CPanelPtr( const CPanelPtr &rhs ) { *this = rhs; }
+	CPanelPtr( const IUIPanel *pPanel ) { Set( pPanel ); }
+	CPanelPtr( const IUIPanelClient *pPanel ) { Set( pPanel ? pPanel->UIPanel() : (IUIPanel*)NULL ); }
+
+	CPanelPtr< T > &operator=( const CPanelPtr< T > &ptr ) { m_handle = ptr.m_handle; return *this; }
+	T *operator=( T *pPanel ) { Set( pPanel ); return pPanel; }
+
+	void Clear()
+	{
+		m_handle = PanelHandle_t::InvalidHandle();
+	}
+
+	void Set( const IUIPanel *pPanel )
+	{
+		if( pPanel )
+			m_handle = UIEngine()->GetPanelHandle( pPanel );
+		else
+			Clear();
+	}
+
+	void Set( const IUIPanelClient *pPanel )
+	{
+		if( pPanel )
+			m_handle = UIEngine()->GetPanelHandle( pPanel->UIPanel() );
+		else
+			Clear();
+	}
+
+	T * Get() const
+	{
+		if ( m_handle == PanelHandle_t::InvalidHandle() )
+			return NULL;
+
+		// allow us to be called to return NULL pointers early
+		if( UIEngine() == NULL )
+		{
+			return NULL;
+		}
+
+		if( panorama_is_base_of< IUIPanel, T >::value )
+		{ 
+			T* pPanel = (T *)UIEngine()->GetPanelPtr( m_handle );
+			if ( pPanel )
+			{
+				return pPanel;
+			}
+			else 
+			{
+				m_handle = PanelHandle_t::InvalidHandle();
+				return NULL;
+			}
+		}
+		else
+		{
+			IUIPanel *pPanel = UIEngine()->GetPanelPtr( m_handle );
+			if( pPanel )
+				return (T*)(pPanel->ClientPtr());
+			else
+			{
+				m_handle = PanelHandle_t::InvalidHandle();
+				return NULL;
+			}
+		}
+	}
+
+	T *operator->() const
+	{
+		return Get();
+	}
+
+	template < class U >
+	bool operator==( const CPanelPtr< U > &rhs ) const
+	{
+		return ( m_handle == rhs.GetPanelHandle() );
+	}
+
+	template < class U >
+	bool operator!=( const CPanelPtr< U > &rhs ) const
+	{
+		return !operator==( rhs );
+	}
+	
+	template < class U >
+	bool operator<( const CPanelPtr< U > &rhs) const
+	{
+		return m_handle < rhs.m_handle;
+	}
+
+	uint64 GetHandleAsUInt64() const
+	{
+		uint64 val = 0;
+		val = ((uint64)m_handle.m_unSerialNumber)<<32 | m_handle.m_iPanelIndex;
+		return val;
+	}
+
+	void SetFromUInt64( uint64 ulValue )
+	{
+		m_handle.m_unSerialNumber = ulValue>>32;
+		m_handle.m_iPanelIndex = 0xFFFFFFFF & ulValue;
+	}
+
+	const PanelHandle_t &GetPanelHandle() const { return m_handle; }
+	bool BPreviouslySet() { return ( m_handle != PanelHandle_t::InvalidHandle() ); }
+
+private:
+	mutable PanelHandle_t m_handle;
+};
+
+template< class T > 
+inline uint32 HashItem( const CPanelPtr<T> &item )
+{
+#if defined( SOURCE2_PANORAMA )
+	return ::HashItem( item );
+#else
+	return HashItemAsBytes( item );
+#endif
+}
+
+} // namespace panorama
+
+
+#endif // PANELPTR_H
diff --git a/public/panorama/controls/progressbar.h b/public/panorama/controls/progressbar.h
new file mode 100644
index 0000000..3771e4e
--- /dev/null
+++ b/public/panorama/controls/progressbar.h
@@ -0,0 +1,51 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_PROGRESSBAR_H
+#define PANORAMA_PROGRESSBAR_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panorama/controls/panel2d.h"
+
+namespace panorama
+{
+
+//////////////////////////////////////////////////////////////////////////
+//
+// progress bar, just sizes two panels to represent progress
+//
+class CProgressBar: public CPanel2D
+{
+	DECLARE_PANEL2D( CProgressBar, CPanel2D );
+public:
+	CProgressBar( CPanel2D *pParent, const char *pchID );
+	virtual ~CProgressBar();
+
+	void SetMin( float flMin ) { m_flMin = flMin; InvalidateSizeAndPosition(); }
+	void SetMax( float flMax ) { m_flMax = flMax; InvalidateSizeAndPosition(); }
+	void SetValue( float flValue ) { m_flCur = flValue; InvalidateSizeAndPosition(); }
+	float GetValue() { return m_flCur; }
+
+protected:
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+
+private:
+	float m_flMin;
+	float m_flMax;
+	float m_flCur;
+
+	CPanel2D *m_ppanelLeft;
+	CPanel2D *m_ppanelRight;
+
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_PROGRESSBAR_H
+
+
diff --git a/public/panorama/controls/slider.h b/public/panorama/controls/slider.h
new file mode 100644
index 0000000..6ac4d9f
--- /dev/null
+++ b/public/panorama/controls/slider.h
@@ -0,0 +1,123 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_SLIDER_H
+#define PANORAMA_SLIDER_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panorama/controls/panel2d.h"
+
+namespace panorama
+{
+
+DECLARE_PANEL_EVENT1( SliderValueChanged, float );
+DECLARE_PANEL_EVENT1( SlottedSliderValueChanged, int );
+DECLARE_PANEL_EVENT1( SliderFocusChanged, bool );
+
+//-----------------------------------------------------------------------------
+// Purpose: Slider control which includes track, progress & thumb
+//-----------------------------------------------------------------------------
+class CSlider: public CPanel2D
+{
+	DECLARE_PANEL2D( CSlider, CPanel2D );
+
+public:
+	CSlider( CPanel2D *pParent, const char *pchID );
+	virtual ~CSlider();
+
+	enum ESliderDirection
+	{
+		k_EDirectionVertical,
+		k_EDirectionHorizontal
+	};
+
+	void SetMin( float flMin ) { m_flMin = flMin; InvalidateSizeAndPosition(); }
+	void SetMax( float flMax ) { m_flMax = flMax; InvalidateSizeAndPosition(); }
+	void SetIncrement( float flValue ) { m_flIncrement = flValue; }
+	virtual void SetValue( float flValue );
+	float GetValue() { return m_flCur; }
+	float GetDefaultValue() { return m_flDefault; }
+	void SetDefaultValue ( float flValue ) { m_flDefault = flValue; }
+	void SetShowDefaultValue( bool bShow ) { m_bShowDefault = bShow; }
+	void SetDirection( ESliderDirection eValue );
+
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue );
+
+	virtual bool OnMouseButtonDown( const MouseData_t &code ) OVERRIDE;
+	virtual bool OnMouseButtonUp( const MouseData_t &code ) OVERRIDE;
+	virtual void OnMouseMove( float flMouseX, float flMouseY ) OVERRIDE;
+	virtual bool OnMoveUp( int nRepeats ) OVERRIDE;
+	virtual bool OnMoveRight( int nRepeats ) OVERRIDE;
+	virtual bool OnMoveDown( int nRepeats ) OVERRIDE;
+	virtual bool OnMoveLeft( int nRepeats ) OVERRIDE;
+
+	virtual bool OnActivate(panorama::EPanelEventSource_t eSource);
+	virtual bool OnCancel(panorama::EPanelEventSource_t eSource);
+	virtual void OnStyleFlagsChanged();
+	virtual void OnResetToDefaultValue();
+
+	void SetRequiresSelection( bool bRequireSelection ) { m_bRequiresSelection = bRequireSelection; }
+
+protected:
+	bool EventPanelActivated( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+	void SetValueFromMouse( float x, float y );
+	float GetMin() { return m_flMin; }
+	float GetMax() { return m_flMax; }
+	ESliderDirection GetDirection() { return m_eDirection; }
+
+	CPanel2D *m_pThumb;
+	CPanel2D *m_pTrack;
+	CPanel2D *m_pProgress;
+	CPanel2D *m_pDefaultTick;
+	bool EventActivated( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel, panorama::EPanelEventSource_t eSource );
+	bool EventCancelled( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel, panorama::EPanelEventSource_t eSource );
+	bool EventStyleFlagsChanged( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel );
+	bool EventResetToDefault( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel );
+
+private:
+	bool AllowInteraction( void );
+	bool ShouldShowDefault( void ) { return m_bShowDefault; }
+
+	float m_flMin;
+	float m_flMax;
+	float m_flDefault;
+	float m_flCur;
+	float m_flLast;
+	float m_flIncrement;
+	bool m_bRequiresSelection;
+	bool m_bDraggingThumb;
+	bool m_bShowDefault;
+	ESliderDirection m_eDirection;
+
+	float m_flLastMouseX;
+	float m_flLastMouseY;
+};
+
+class CSlottedSlider : public CSlider
+{
+	DECLARE_PANEL2D( CSlottedSlider, CSlider );
+public:
+	CSlottedSlider( CPanel2D *pParent, const char *pchID );
+	virtual ~CSlottedSlider();
+
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue );
+	virtual void SetValue( float flValue );
+	void SetValue( int nValue );
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+	int GetCurrentNotch() { return m_nCurNotch; }
+
+private:
+	int m_nNumNotches;
+	int m_nCurNotch;
+	CUtlVector< CPanel2D* > m_pNotches;
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_SLIDER_H
diff --git a/public/panorama/controls/slideshow.h b/public/panorama/controls/slideshow.h
new file mode 100644
index 0000000..cfa14ec
--- /dev/null
+++ b/public/panorama/controls/slideshow.h
@@ -0,0 +1,114 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_SLIDESHOW_H
+#define PANORAMA_SLIDESHOW_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panorama/controls/panel2d.h"
+#include "panorama/controls/mousescroll.h"
+
+namespace panorama
+{
+
+DECLARE_PANEL_EVENT1( SlideShowPanelChanged, int );
+DECLARE_PANEL_EVENT0( SlideShowOnLayoutInitialized );
+
+//-----------------------------------------------------------------------------
+// Purpose: Panel that shows a slideshow of panels
+//-----------------------------------------------------------------------------
+class CSlideShow : public CPanel2D
+{
+	DECLARE_PANEL2D( CSlideShow, CPanel2D );
+
+public:
+	CSlideShow( CPanel2D *pParent, const char *pchID );
+	virtual ~CSlideShow();
+
+	void AddPanel( CPanel2D *pPanel, bool bDontSetFocusBySideEffect );
+	void RemoveAndDeletePanel( CPanel2D *pPanel );
+	void SetManageFocus( bool bManageFocus ) { m_bManageFocus = bManageFocus; }
+
+	void SetFocusIndex( int iFocus, bool bSkipChildCountCheck = false );
+	int GetFocusIndex() { return m_iFocusChild; }
+	CPanel2D *GetFocusChild() { return GetChild(m_iFocusChild); }
+	bool BFocusChildRightMost() { return (m_iFocusChild == (GetChildCount() - 1)); }
+
+	virtual bool OnMoveRight( int nRepeats );
+	virtual bool OnMoveLeft( int nRepeats );
+	virtual bool OnTabForward( int nRepeats );
+	virtual bool OnTabBackward( int nRepeats );
+
+	virtual void Paint();
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+
+	virtual bool OnSetFocusToNextPanel( int nRepeats, EFocusMoveDirection moveType, bool bAllowWrap, float flTabIndexCurrent, float flXPosCurrent, float flYPosCurrent, float flXStart, float fYStart ) OVERRIDE
+	{
+		switch( moveType )
+		{
+		case k_ENextInTabOrder:
+			if ( m_bManageFocus && OnTabForward( nRepeats ) )
+				return true;
+			break;
+		case k_ENextByXPosition:
+			if ( m_bManageFocus && OnMoveRight( nRepeats ) )
+				return true;
+			break;
+		case k_EPrevInTabOrder:
+			if ( m_bManageFocus && OnTabBackward( nRepeats ) )
+				return true;
+			break;
+		case k_EPrevByXPosition:
+			if ( m_bManageFocus && OnMoveLeft( nRepeats ) )
+				return true;
+			break;
+		case k_ENextByYPosition:
+			if ( m_bManageFocus && OnMoveDown( nRepeats ) )
+				return true;
+			break;
+		case k_EPrevByYPosition:
+			if ( m_bManageFocus && OnMoveUp( nRepeats ) )
+				return true;
+			break;
+		default:
+			break;
+		}
+
+		return false;
+	}
+
+	virtual panorama::IUIPanel *OnGetDefaultInputFocus() OVERRIDE;
+
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
+#endif
+
+protected:
+	bool EventInputFocusSet( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel );
+	bool EventCarouselMouseScroll( const CPanelPtr< IUIPanel > &ptrPanel, int cRepeat );
+	bool EventSlideShowOnLayoutInitialized( const CPanelPtr< IUIPanel > &ptrPanel );
+	virtual void OnInitializedFromLayout();
+	void SetPanelStyles( int iOldFocus, int iNewFocus );
+	void LayoutMouseScrollRegions( float flFinalWidth, float flFinalHeight );
+
+private:
+	virtual void AddDisabledFlagToChildren() OVERRIDE;
+	virtual void RemoveDisabledFlagFromChildren() OVERRIDE;
+	void SetIndividualPanelStyle( int iChild, int iOldFocus, int iNewFocus );
+	void SetMouseScrollVisibility( int iFocus );
+
+	int m_iFocusChild;
+	bool m_bManageFocus;
+	CMouseScrollRegion *m_pLeftMouseScrollRegion;
+	CMouseScrollRegion *m_pRightMouseScrollRegion;
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_SLIDESHOW_H
diff --git a/public/panorama/controls/source2/renderpanel.h b/public/panorama/controls/source2/renderpanel.h
new file mode 100644
index 0000000..b6e1c67
--- /dev/null
+++ b/public/panorama/controls/source2/renderpanel.h
@@ -0,0 +1,45 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_RENDERPANEL_H
+#define PANORAMA_RENDERPANEL_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panorama/controls/panel2d.h"
+#include "materialsystem2/imaterialsystem2utils.h"
+
+namespace panorama
+{
+
+//-----------------------------------------------------------------------------
+// Purpose: Render panel, to use for raw source2 render operations directly in render thread
+//-----------------------------------------------------------------------------
+class CRenderPanel : public CPanel2D
+{
+	DECLARE_PANEL2D( CRenderPanel, CPanel2D );
+
+public:
+	CRenderPanel( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CRenderPanel();
+
+	void SetRenderThreadCallback( CRenderThreadCallback *pRenderCallback );
+
+	// Override and make return true if you need to paint every single frame, and will not manually call SetRepaint when you want to repaint
+	virtual bool BShouldAlwaysRepaint() { return true; }
+
+protected:
+	// Override of Panel2D paint
+	virtual void Paint() OVERRIDE;
+
+private:
+	CRenderThreadCallback *m_pRenderCallback;
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_RENDERPANEL_H
diff --git a/public/panorama/controls/textentry.h b/public/panorama/controls/textentry.h
new file mode 100644
index 0000000..87068d0
--- /dev/null
+++ b/public/panorama/controls/textentry.h
@@ -0,0 +1,361 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_TEXTENTRY_H
+#define PANORAMA_TEXTENTRY_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "panorama/text/iuitextlayout.h"
+#include "panorama/textinput/textinput.h"
+#include "panorama/textinput/textinput_settings.h"
+#if !defined(SOURCE2_PANORAMA)
+#include "../common/globals.h"
+#include "../common/reliabletimer.h"
+#include "../common/framefunction.h"
+#endif
+#include "panorama/uischeduleddel.h"
+#include "imesystem/imeuiinterface.h"
+
+namespace panorama
+{
+
+class CLabel;
+class CTextEntryAutocomplete;
+
+#if defined( SOURCE2_PANORAMA )
+class CTextEntryIMEControls;
+#endif // defined( SOURCE2_PANORAMA )
+
+DECLARE_PANEL_EVENT1( TextEntrySubmit, const char * );		// always raised when user is done submitting text
+DECLARE_PANEL_EVENT0( TextEntryChanged );					// call CTextEntry::RaiseChangeEvents() to enable
+DECLARE_PANEL_EVENT0( TextEntryShowTextInputHandler );
+DECLARE_PANEL_EVENT0( TextEntryHideTextInputHandler );
+DECLARE_PANEL_EVENT0( TextEntryInsertFromClipboard );
+DECLARE_PANEL_EVENT0( TextEntryCopyToClipboard );
+DECLARE_PANEL_EVENT0( TextEntryCutToClipboard );
+
+//-----------------------------------------------------------------------------
+// Purpose: text entry
+//-----------------------------------------------------------------------------
+class CTextEntry : public CPanel2D, public ITextInputControl
+#if defined( SOURCE2_PANORAMA )
+	, public IIMEUITextField
+#endif // defined( SOURCE2_PANORAMA )
+{
+	DECLARE_PANEL2D( CTextEntry, CPanel2D );
+
+public:
+	CTextEntry( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CTextEntry();
+
+	virtual void SetupJavascriptObjectTemplate() OVERRIDE;
+
+	void SetUndoHistoryEnabled( bool bEnabled );
+	void ClearUndoHistory();
+
+	virtual bool OnKeyDown( const KeyData_t &code );
+	virtual bool OnKeyTyped( const KeyData_t &unichar );
+	virtual bool OnKeyUp( const KeyData_t & code ) { return BaseClass::OnKeyUp( code ); }
+	virtual void Paint();
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+	virtual void OnInitializedFromLayout();
+	virtual void OnStylesChanged();
+
+	virtual void OnMouseMove( float flMouseX, float flMouseY );
+	virtual bool OnMouseButtonDown( const MouseData_t &code );
+	virtual bool OnMouseButtonUp( const MouseData_t &code );
+	virtual bool OnMouseButtonDoubleClick( const MouseData_t &code );
+	virtual bool OnMouseButtonTripleClick( const MouseData_t &code );
+
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+	virtual void GetDebugPropertyInfo( CUtlVector< DebugPropertyOutput_t *> *pvecProperties ) OVERRIDE;
+
+	virtual bool BRequiresContentClipLayer() { return m_bMayDrawOutsideBounds; }
+
+	void SetMode( ETextInputMode_t mode );
+	ETextInputMode_t GetMode() { return m_modeInput; }
+
+	void SetText( const char *pchValue );
+	const char *PchGetText() const;
+	const wchar_t *PwchGetText() const;
+	void SetPlaceholderText( const char *pchValue );
+	const char *PchGetPlaceholderText() const;
+	void SetMaxChars( uint unMaxChars );
+	uint GetCharCount() const { return m_vecWCharData.Count() - 1; }	// m_vecWCharData is terminated, so remove extra char count
+	uint GetMaxCharCount() const { return m_unMaxChars; }
+	int32 GetCursorOffset() const { return m_nCursorOffset; }
+	void SetCursorOffset( int32 nCursoroffset );
+	bool BSupportsImmediateTextReturn() { return true; }
+	void RequestControlString() { Assert( false ); } // no op, we already have the string
+
+	// Insert clipboard contents into text entry
+	void InsertFromClipboard();
+
+	// Cut selected text to clipboard
+	void CutToClipboard();
+
+	// Copy selected text to clipboard
+	void CopyToClipboard();
+
+	bool OnInsertFromClipboard( const CPanelPtr< IUIPanel > &pPanel );
+	bool OnCutToClipboard( const CPanelPtr< IUIPanel > &pPanel );
+	bool OnCopyToClipboard( const CPanelPtr< IUIPanel > &pPanel );
+
+	void SetAlwaysRenderCaret( bool bAlwaysRenderCaret );
+
+	// Delete currently selected text 
+	void DeleteSelection( bool bDontPushUndoHistory );
+
+	// Clear selection region, leaving nothing selected
+	void ClearSelection();
+
+	// select all the text in the control
+	void SelectAll();
+
+	// Lock the selection in place; it can only be unlocked or deleted
+	void LockSelection( bool bLockSelection ) { m_bSelectionLocked = bLockSelection; }
+
+	// Insert characters at cursor
+	void InsertCharacterAtCursor( const wchar_t &unichar );
+	void InsertCharactersAtCursor( const wchar_t *pwch, size_t cwch );
+
+	bool BIsValidCharacter( const wchar_t wch );
+
+	void RaiseChangeEvents( bool bEnable ) { m_bRaiseChangeEvents = bEnable; }
+
+	virtual EMouseCursors GetMouseCursor();
+
+	// ITextInputControl helpers
+	virtual CPanel2D *GetAssociatedPanel() { return this; }
+
+	panorama::CTextInputHandler *GetTextInputHandler() { return m_pTextInputHandler.Get(); }
+	void SetTextInputHandler( panorama::CTextInputHandler *pTextInputHandler );
+
+	virtual bool BRequiresFocus() OVERRIDE { return true; }
+
+	// Autocomplete
+	void ClearAutocomplete( void );
+	void AddAutocomplete( const char *pszOption );
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName );
+#endif
+	int32 GetSelectionStart() { return m_nSelectionStartIndex; }
+	int32 GetSelectionEnd() { return m_nSelectionEndIndex; }
+
+	// Interface for IIMEUITextField
+#if defined( SOURCE2_PANORAMA )
+	virtual void IME_SetLoggingChannel( LoggingChannelID_t loggingChannel ) OVERRIDE;
+	virtual bool IME_IsEnabled() OVERRIDE;
+	virtual IMEUIObjectType IME_GetObjectType() OVERRIDE;
+	virtual wchar_t *IME_GetCompositionString() OVERRIDE;
+	virtual void IME_CreateCompositionString() OVERRIDE;
+	virtual void IME_ClearCompositionString() OVERRIDE;
+	virtual void IME_CommitCompositionString( const wchar_t *pString ) OVERRIDE;
+	virtual void IME_SetCompositionStringText( const wchar_t *pString ) OVERRIDE;
+	virtual void IME_SetCompositionStringPosition( uint32 nPos ) OVERRIDE;
+	virtual void IME_SetCursorInCompositionString( uint32 nPos ) OVERRIDE;
+	virtual uint32 IME_GetCaretIndex() OVERRIDE;
+	virtual uint32 IME_GetBeginIndex() OVERRIDE;
+	virtual uint32 IME_GetEndIndex() OVERRIDE;
+	virtual void IME_ReplaceCharacters( const wchar_t *pString, uint32 nStart, uint32 nEnd ) OVERRIDE;
+	virtual void IME_SetSelection( uint32 nStart, uint32 nEnd ) OVERRIDE;
+	virtual void IME_SetWideCursor( bool bWide ) OVERRIDE;
+	virtual void IME_HighlightCompositionStringText( uint32 nPos, uint32 nLen, IMETextHighlightStyle highlightStyle ) OVERRIDE;
+	virtual void IME_DeleteSelection() OVERRIDE;
+	virtual	void IME_RemoveInputWindow() OVERRIDE;
+	virtual	void IME_DisplayInputWindow( const wchar_t *pReadingString, const IMERectF *pPosition ) OVERRIDE;
+	virtual	void IME_RepositionInputWindow( const IMERectF *pPosition ) OVERRIDE;
+	virtual	void IME_CreateList( int nPageSize, int nListStartsAt1 ) OVERRIDE;
+	virtual	void IME_RemoveList() OVERRIDE;
+	virtual	void IME_ClearList() OVERRIDE;
+	virtual	void IME_ShowList( bool bShow ) OVERRIDE;
+	virtual	void IME_RepositionCandidateList( const IMERectF *pPosition ) OVERRIDE;
+	virtual	void IME_SelectItemInList( int32 nItemToSelect ) OVERRIDE;
+	virtual	void IME_AddToList( const wchar_t *pCandidateString ) OVERRIDE;
+#endif // defined( SOURCE2_PANORAMA )
+
+protected:
+	virtual void OnContentSizeTraverse( float *pflContentWidth, float *pflContentHeight, float flMaxWidth, float flMaxHeight, bool bFinalDimensions );
+	virtual bool BIsClientPanelEvent( CPanoramaSymbol symProperty ) OVERRIDE;
+
+private:
+	bool OnTextEntryShowTextInputHandler( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel );
+	bool OnTextEntryHideTextInputHandler( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel );
+	bool EventActivated ( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+	bool OnTextEntryScrollToCursor( const panorama::CPanelPtr< panorama::IUIPanel > &ptrPanel );
+	bool EventInputFocusTopLevelChanged( CPanelPtr< CPanel2D > ptrPanel );
+	bool HandleTextInputFinished( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel, bool bFinished, char const *pchText );
+	bool EventInputFocusSet( const CPanelPtr< IUIPanel > &ptrPanel );
+	bool EventInputFocusLost( const CPanelPtr< IUIPanel > &ptrPanel );
+
+	IUITextLayout *CreateTextLayout( float flWidth, float flHeight );
+	void RemoveCharacter( int32 offset );
+	void RaiseTextChangedEvent();
+
+	void UpdateSelectionToInclude( int32 unPreviousCursor, int32 unNewCursorPos );
+
+	void Undo();
+	void Redo();
+	void PushUndoStack();
+	void PushRedoStack();
+
+	void UpdateCapsLockWarning();
+	void OnScheduledCapsLockCheck();
+
+	void MoveCaretToEnd( bool bIsShiftHeld );
+
+	const wchar_t *PwchGetTextDisplay(); // honors password-entry mode
+
+	bool m_bUndoHistoryEnabled;
+
+	bool m_bContentSizeDirty;				// content size is dirty - text has changed
+
+	float m_flMaxWidthLastContentSize;
+	float m_flMaxHeightLastContentSize;
+
+	bool m_bCaretPositionDirty;
+	bool m_bAlwaysRenderCaret;
+
+	bool m_bMayDrawOutsideBounds;
+
+	bool m_bShowTextInputHandlerOnLeftMouseUp;
+
+	bool m_bSelectionLocked;
+	bool m_bMultiline;					// used to determine whether to swallow multiline-only characters (\n, etc.)
+
+	Vector2D m_LastMousePos;
+	CUtlVector<wchar_t> m_vecWCharData;
+	CUtlVector<wchar_t> m_vecWCharDataPasswordDisplay;
+	mutable CUtlString m_UTF8String;
+	mutable bool m_bUTF8StringInvalid;
+	uint32 m_unMaxChars;
+
+	int32 m_nCursorOffset;
+	Vector2D m_CaretCoords;
+	float m_flCaretHeight;
+
+	bool m_bLeftMouseIsDown;
+	bool m_bSelectionRectDirty;
+	int32 m_nSelectionStartIndex;
+	int32 m_nSelectionEndIndex;
+
+	bool m_bScrollableSizeDirty;
+	float m_flLastFinalWidthToScrollable;
+	float m_flLastFinalHeightToScrollable;
+
+	// Translation of text in single line entries to scroll to show where the cursor is
+	float m_flTextXTranslate;
+   
+	CPanelPtr< CTextInputHandler > m_pTextInputHandler; 
+
+	CUtlVector<IUITextLayout::HitTestRegionRect_t> m_vecSelectionRects;
+	panorama::CTextInputHandlerSettings m_settingsTextInput;
+
+	CUtlVector< wchar_t * > m_vecUndoStack;
+	CUtlVector< wchar_t * > m_vecRedoStack;
+
+	double m_flFocusTime;
+
+	// only raise text changed events when requested, as we have to convert every character to UTF8 from unicode
+	bool m_bRaiseChangeEvents;
+
+	ETextInputMode_t m_modeInput;
+
+	bool m_bDisplayInput;
+	bool m_bWarnOnCapsLock;
+	panorama::CUIScheduledDel m_scheduledCapsLockCheck;
+
+	CLabel *m_pPlaceholderText;
+	
+	CPanelPtr< CTextEntryAutocomplete > m_pAutocompleteMenu;
+
+#if defined( SOURCE2_PANORAMA )
+	// IME State
+	bool m_bIMEWideCursor;
+	CUtlVector< wchar_t > m_IMECompositionString;
+	int32 m_nIMECompositionCursor;
+	int32 m_nIMEStartingCursorInsertionOffset;
+	int32 m_nIMEEndingCursorInsertionOffset;
+	bool m_bIMERejectBackspace;
+
+	CPanelPtr< CTextEntryIMEControls > m_pIMEControls;
+	LoggingChannelID_t m_IMELoggingChannel;
+#endif // defined( SOURCE2_PANORAMA )
+};
+
+class CTextEntryAutocomplete : public CPanel2D
+{
+	DECLARE_PANEL2D( CTextEntryAutocomplete, CPanel2D );
+
+public:
+	CTextEntryAutocomplete( CTextEntry *pParent, const char *pchPanelID );
+	virtual ~CTextEntryAutocomplete();
+
+	void DeleteSelf( bool bSetFocusToTarget = true );
+
+	void AddOption( const char *pszOption );
+
+private:
+	// forward keys, arrows back to my parent
+	virtual bool OnKeyDown( const KeyData_t &code );
+	virtual bool OnKeyUp( const KeyData_t & code );
+	virtual bool OnKeyTyped( const KeyData_t &unichar );
+
+	void PositionNearParent();
+
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+
+	// events
+	bool EventPanelActivated( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );
+	bool EventInputFocusSet( const CPanelPtr< IUIPanel > &pPanel );
+
+	void SuggestionSelected( CLabel *pLabel );
+
+	CPanelPtr< CTextEntry > m_pTextEntryParent;
+	bool m_bClosing;
+};
+
+#if defined( SOURCE2_PANORAMA )
+class CTextEntryIMEControls : public CPanel2D
+{
+	DECLARE_PANEL2D( CTextEntryIMEControls, CPanel2D );
+
+public:
+	CTextEntryIMEControls( CTextEntry *pParent, const char *pchPanelID );
+	virtual ~CTextEntryIMEControls();
+
+	void ClearCandidateList();
+	void CreateCandidateList( int nPageSize, int nListStartsAt1 );
+	void AddCandidate( const wchar_t *pszCandidateString );
+	void SetSelectedCandidate( int nItemToSelect );
+	void ShowCandidateList( bool bShow );
+
+	void SetReadingString( const wchar_t *pReadingString );
+
+private:
+	void PositionNearParent();
+
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+
+	CPanelPtr< CTextEntry > m_pTextEntryParent;
+
+	CPanelPtr< CLabel > m_pReadingStringLabel;
+	CPanelPtr< CPanel2D > m_pCandidateList;
+
+	int m_nCandidateListPageSize;
+	int m_nCandidateListSelectedIndex;
+
+	bool m_bShowCandidateList;
+};
+#endif // defined( SOURCE2_PANORAMA )
+
+} // namespace panorama
+
+#endif // PANORAMA_TEXTENTRY_H
diff --git a/public/panorama/controls/tooltip.h b/public/panorama/controls/tooltip.h
new file mode 100644
index 0000000..31071b3
--- /dev/null
+++ b/public/panorama/controls/tooltip.h
@@ -0,0 +1,81 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef PANORAMA_TOOLTIP_H
+#define PANORAMA_TOOLTIP_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "../uievent.h"
+#include "label.h"
+
+namespace panorama
+{
+
+DECLARE_PANEL_EVENT0( TooltipVisible );
+
+//-----------------------------------------------------------------------------
+// Purpose: Top level panel for a tooltip
+//-----------------------------------------------------------------------------
+class CTooltip : public CPanel2D
+{
+	DECLARE_PANEL2D( CTooltip, CPanel2D );
+
+public:
+	CTooltip( IUIWindow *pParent, const char *pchName );
+	CTooltip( CPanel2D *pParent, const char *pchName );
+	virtual ~CTooltip();
+
+	void SetTooltipTarget( const CPanelPtr< IUIPanel >& targetPanelPtr );
+
+	// Get/set tooltip visibility.  This is actually determined by a .css class,
+	// so that transitions can be supported
+	bool IsTooltipVisible() const;
+	void SetTooltipVisible( bool bVisible );
+
+	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight );
+
+	// request the tooltip to do positioning on the next layout
+	virtual void CalculatePosition() { m_bReposition = true; InvalidateSizeAndPosition(); }
+
+private:
+
+	void Init();
+	void UpdatePosition();
+
+	bool EventTooltipVisible( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel );
+
+	bool m_bReposition;
+
+	CPanelPtr< IUIPanel > m_pTooltipTarget;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Simple tooltip that just shows a string of text
+//-----------------------------------------------------------------------------
+class CTextTooltip : public CTooltip
+{
+	DECLARE_PANEL2D( CTextTooltip, CTooltip );
+
+public:
+	CTextTooltip( IUIWindow *pParent, const char *pchName );
+	CTextTooltip( CPanel2D *pParent, const char *pchName );
+	virtual ~CTextTooltip();
+
+	void SetText( const char *pchText, CLabel::ETextType eTextType = CLabel::k_ETextTypePlain );
+
+private:
+	void Init();
+
+	CLabel *m_pText;
+};
+
+} // namespace panorama
+
+#endif // PANORAMA_TOOLTIP_H
\ No newline at end of file
diff --git a/public/panorama/controls/verticalscrolllist.h b/public/panorama/controls/verticalscrolllist.h
new file mode 100644
index 0000000..a9b6c51
--- /dev/null
+++ b/public/panorama/controls/verticalscrolllist.h
@@ -0,0 +1,38 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef VERTICALSCROLLLIST_H
+#define VERTICALSCROLLLIST_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panel2d.h"
+#include "panorama/controls/label.h"
+
+namespace panorama
+{
+
+//-----------------------------------------------------------------------------
+// Purpose: CVerticalScrollList
+//-----------------------------------------------------------------------------
+class CVerticalScrollList : public CPanel2D
+{
+	DECLARE_PANEL2D( CVerticalScrollList, CPanel2D );
+
+public:
+	CVerticalScrollList( CPanel2D *parent, const char * pchPanelID );
+	virtual ~CVerticalScrollList();
+
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+
+private:
+};
+
+
+} // namespace panorama
+
+#endif // VERTICALSCROLLLIST_H
diff --git a/public/panorama/controls/vumeter.h b/public/panorama/controls/vumeter.h
new file mode 100644
index 0000000..2dc3a11
--- /dev/null
+++ b/public/panorama/controls/vumeter.h
@@ -0,0 +1,86 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef VUMETER_H
+#define VUMETER_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panorama/controls/panel2d.h"
+
+namespace panorama
+{
+
+DECLARE_PANEL_EVENT1( VUMeterBarsChanged, int );
+
+//////////////////////////////////////////////////////////////////////////
+//
+// volume bars control for volume/mic levels
+//
+class CVUMeter: public panorama::CPanel2D
+{
+	DECLARE_PANEL2D( CVUMeter, panorama::CPanel2D );
+public:
+	CVUMeter( panorama::CPanel2D *pParent, const char *pchID );
+	virtual ~CVUMeter();
+
+	virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) OVERRIDE;
+
+	virtual void OnInitializedFromLayout();
+
+	int GetNumActiveBars() const { return m_numActive; }
+	void SetNumActiveBars( int numActive );
+
+	int GetNumBarsTotal() const { return m_numBars; }
+
+	virtual bool OnMoveLeft( int cRepeats );
+	virtual bool OnMoveRight( int cRepeats );
+
+	// Override these to avoid focus slipping away when setting with analog
+	virtual bool OnMoveUp( int nRepeats );
+	virtual bool OnMoveDown( int nRepeats );
+
+	virtual bool OnMouseButtonUp(const MouseData_t &code);
+	virtual bool OnMouseWheel(const MouseData_t &code);
+	virtual void OnMouseMove(float flMouseX, float flMouseY);
+
+	virtual bool OnActivate(panorama::EPanelEventSource_t eSource);
+	virtual bool OnCancel(panorama::EPanelEventSource_t eSource);
+	virtual void OnStyleFlagsChanged();
+
+	// if VU meter is "writable," it will be a tab stop, and be focusable. when activated
+	// it will enter a mode where you can set the bar with the dpad. if VU meter is not
+	// writable, it just displays a value.
+	void SetWritable( bool bWritable );
+
+	bool EventActivated( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel, panorama::EPanelEventSource_t eSource );
+	bool EventCancelled( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel, panorama::EPanelEventSource_t eSource );
+	bool EventStyleFlagsChanged( const panorama::CPanelPtr< panorama::IUIPanel > &pPanel );
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
+#endif
+
+protected:
+	bool OnLeftRight( int dx );
+
+	bool m_bWritable;
+	int m_numBars, m_numActive;
+	CPanoramaSymbol m_symBarPanelType;
+	CPanoramaSymbol m_symBarPanelAddClass;
+	CPanoramaSymbol m_symBarPanelActiveClass;
+	CUtlVector< panorama::CPanel2D * > m_arrBars;
+
+	float m_flLastMouseX;
+	float m_flLastMouseY;
+};
+
+} // namespace panorama
+
+#endif // VUMETER_H
+
+