d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
128 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 5b926feae6
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5b926feae6'
${ noResults }
source-engine/public/panorama/controls/html.h

768 lines
30 KiB
Raw Blame History

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