path: root/public/panorama/controls/html.h

//=========== 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