Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

769 lines
30 KiB

5 years ago
//=========== 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