1HEADmaster

1 files changed, 299 insertions, 0 deletions

diff --git a/public/panorama/uitoplevelwindow.h b/public/panorama/uitoplevelwindow.h
new file mode 100644
index 0000000..321b757
--- /dev/null
+++ b/public/panorama/uitoplevelwindow.h
@@ -0,0 +1,299 @@
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef UITOPLEVELWINDOW_H
+#define UITOPLEVELWINDOW_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "utlstring.h"
+#include "utlmap.h"
+#include "utllinkedlist.h"
+#if !defined( SOURCE2_PANORAMA )
+#include "constants.h"
+#include "globals.h"
+#endif
+#include "reliabletimer.h"
+#if !defined( SOURCE2_PANORAMA )
+#include "framefunction.h"
+#endif
+#include "input/iuiinput.h"
+#include "input/mousecursors.h"
+#include "iuiengine.h"
+#include "color.h"
+#include "uievent.h"
+#include "iuiwindow.h"
+#include "iuirenderengine.h"
+#include "uipanel.h"
+
+namespace panorama
+{
+
+class CUIRenderEngine;
+class CPanel2D;
+class CUIWindowInput;
+class CUIEngine;
+class CMouseCursorTexture;
+class CImageResourceManager;
+class CFastScrollSoundManager;
+class IUI3DSurface;
+class CMouseCursorRender;
+
+
+//
+// Top level window class
+//
+class CTopLevelWindow : public panorama::IUIWindow
+{
+public:
+	CTopLevelWindow( CUIEngine *pUIEngineParent );
+	virtual ~CTopLevelWindow();
+
+	// Delete the window object
+	virtual void Delete() OVERRIDE{ delete this; }
+
+	// Final step of initialization, post constructor, and post BInitializeSurface() on individidual window type
+	virtual bool FinishInitialization();
+
+	// Run any per window frame func logic
+	virtual void RunPlatformFrame();
+	
+	// Set scaling factor that applies to all x/y values in the UI for the window, used so we can 
+	// author content at say 1080p but pass 0.6666666f for this to render in 720p on cards with poor 
+	// fill rates or TVs without 1080p support.
+	virtual void SetUIScaleFactor( float flScaleFactor ) OVERRIDE;
+	virtual float GetUIScaleFactor() OVERRIDE { return m_flScaleFactor; }
+
+	// Window position/activation management
+	const char * GetTargetMonitor() { return m_strTargetMonitor.String(); }
+	virtual void GetWindowBounds( float &left, float &top, float &right, float &bottom ) = 0;
+	virtual void GetClientDimensions( float &width, float &height ) OVERRIDE = 0;
+
+	virtual bool BAllowInput( InputMessage_t &msg );
+
+	// Access the rendering interface you use to draw onto this window
+	virtual IUIRenderEngine * UIRenderEngine() OVERRIDE{ return (IUIRenderEngine*)m_pRenderEngine; }
+	CUIRenderEngine *GetUIRenderEngine() { return m_pRenderEngine; }
+	virtual bool BIsVisible() { return true; }
+	virtual bool BIsOverlay() OVERRIDE { return UIEngine()->BIsOverlayTarget(m_eRenderTarget); }
+	virtual bool BIsSteamWMOverlay() OVERRIDE { return m_eRenderTarget == IUIEngine::k_ERenderToOverlaySteamWM; }
+
+	virtual bool BIsFullscreen() { return IUIEngine::BIsRenderingToFullScreen( m_eRenderTarget ); }
+	virtual bool BIsFullscreenBorderlessWindow() { return m_eRenderTarget == IUIEngine::k_ERenderBorderlessFullScreenWindow; }
+	bool SetFullscreen( bool bFullscreen );
+	bool BEnforceWindowAspectRatio() { return m_bEnforceWindowAspectRatio; }
+	virtual uint32 GetSurfaceWidth() OVERRIDE { return m_unSurfaceWidth; }
+	virtual uint32 GetSurfaceHeight() OVERRIDE { return m_unSurfaceHeight; }
+	virtual uint32 GetWindowWidth() OVERRIDE { return m_unWindowWidth; }
+	virtual uint32 GetWindowHeight() OVERRIDE { return m_unWindowHeight; }
+	void ConvertClientToSurfaceCoord( float *px, float *py );
+	void GetFPSAverages( float &fpsPaint, float &fpsAnimation, float &fpsRender );
+	virtual void GetSessionFPSAverages( float &fpsPaint, float &fpsAnimation, float &fpsRender ) OVERRIDE;
+	virtual void GetNumPeriodsBelowMinFPS( int &nSlowPeriods ) OVERRIDE;
+
+	// Clear color for the window, normally black, transparent for overlay
+	virtual Color GetClearColor() { return Color( 0, 0, 0, 255 ); }
+
+	// Panel management for the window
+	int AddPanel( CUIPanel *pPanel, bool bVisible );
+	void RemovePanel( int iPanelIndex, bool bVisible );
+	int SetPanelVisible( int iPanelIndex, bool bVisible );
+	virtual void AddClass( const char *pchName ) OVERRIDE;
+	virtual void RemoveClass( const char *pchName ) OVERRIDE;
+
+	// Layout/paint for window
+	virtual void LayoutAndPaintIfNeeded();
+
+	// Paint an empty frame so the animation/render threads will run but do nothing but LRU/clear data
+	virtual void PaintEmptyFrameAndForceLaterRepaint();
+
+	// Layout file auto-reload for windows children panels
+	void ReloadLayoutFile( CPanoramaSymbol symPath );
+	void OnReloadStyleFile( CPanoramaSymbol symPath );
+
+	// Access input engine for window
+	virtual IUIWindowInput *UIWindowInput() OVERRIDE { return (IUIWindowInput *)m_pInputEngine; }
+
+	// custom mouse cursor support, returns true if we want our manually drawn one, false for OS specific ones
+	bool BUseCustomMouseCursor() { return m_bUseCustomMouseCursor; }
+	// used by the os specific case to update the cursor
+	virtual void SetMouseCursor( EMouseCursors eCursor ) = 0;
+	IImageSource *GetMouseCursorTexture( Vector2D *pptHotspot );
+
+	virtual bool BCursorVisible() OVERRIDE;
+	virtual bool BCursorFadingOut() OVERRIDE;
+	virtual void WakeupMouseCursor() OVERRIDE;
+	virtual void FadeOutCursorNow() OVERRIDE;
+	
+	// Access image manager for window
+	CImageResourceManager* AccessImageManager() { return m_pImageResourceManager; }
+
+	// Set a context ptr that is attached to the window, just lets other code (panels) that
+	// has access to the window access some shared state across the window.
+	virtual void SetContextPtr( void *pv ) OVERRIDE { m_pContextPtr = pv; }
+
+	// Get the context ptr that is attached to the window
+	virtual void * GetContextPtr() const OVERRIDE { return m_pContextPtr; }
+
+	void ReloadChangedFile( const char *pchFile );
+	
+	// Access fast scroll sound manager for the window
+	CFastScrollSoundManager * AccessFastScrollSoundMgr();
+
+	void GetMouseWheelRepeats( bool bScrollUp, int lines, uint8 &unRepeats );
+
+	virtual uint32 GetNumVisibleTopLevelPanels() const OVERRIDE { return (uint32)m_listVisiblePanels.Count(); }
+
+	virtual const CUtlLinkedList< IUIPanel* > &GetTopLevelVisiblePanels() const OVERRIDE { return (CUtlLinkedList< IUIPanel* > &)m_listVisiblePanels; }
+
+	// Get the last time the window layed out and painted
+	float GetLastLayoutAndPaintTime() { return m_flLastLayoutAndPaintTime; }
+
+	// Set max FPS for the window
+	void SetMaxFPS( float flMaxFPS );
+
+	// Set a min FPS for the window, this actually just prevents setting the max lower
+	virtual void SetMinFPS( float flMinFPS ) OVERRIDE { m_flMinFPS = flMinFPS; }
+
+	// access data about how the gamepad was used
+	virtual bool BWasGamepadConnectedThisSession() OVERRIDE;
+	virtual bool BWasGamepadUsedThisSession() OVERRIDE;
+
+	virtual bool BWasSteamControllerConnectedThisSession() OVERRIDE;
+	virtual bool BWasSteamControllerUsedThisSession() OVERRIDE;
+
+	// metrics
+	virtual void RecordDaisyWheelUsage( float flEntryTimeInSeconds, int nWordsEntered, bool bViaKeyboard, bool bViaGamepad ) OVERRIDE;
+	virtual void GetDaisyWheelWPM( int &nWordsTyped, float &flMixedWPM, float &flKeyboardOnlyWPM, float &flGamepadOnlyWPM ) OVERRIDE;
+
+	bool BFinishedInitialization() { return m_bFinishedInitialization; }
+
+	virtual bool BIsWindowInLayoutPass() OVERRIDE { return m_bInLayoutTraverse; }
+
+	virtual void SetInhibitInput( bool bInhibitInput ) OVERRIDE;
+	virtual void SetPreventForceWindowOnTop( bool bPreventForceTopLevel ) OVERRIDE;
+
+	// Access overlay window interface for this window, NULL on non Steam Overlay windows
+	virtual IUIOverlayWindow *GetOverlayInterface() OVERRIDE { return NULL; }
+
+	virtual void SetFocusBehavior( EWindowFocusBehavior eFocusBehavior ) OVERRIDE { m_eFocusBehavior = eFocusBehavior; }
+	virtual EWindowFocusBehavior GetFocusBehavior() OVERRIDE{ return m_eFocusBehavior; }
+
+	virtual void OnDeviceLost() OVERRIDE;
+	virtual void OnDeviceRestored() OVERRIDE;
+	virtual bool BDeviceLost() OVERRIDE;
+
+	// Clears the GPU resources associated with the window before the next render frame
+	virtual void ClearGPUResourcesBeforeNextFrame() OVERRIDE;
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName );
+
+	bool PrepareForValidate();
+	bool ResumeFromValidate();
+#endif
+protected:
+
+	// Perform layout prior to paint
+	void PerformLayout();
+	bool BIsGuideButton( const InputMessage_t &msg );
+
+	// Render engine instance for window
+	CUIRenderEngine *m_pRenderEngine;
+
+	// Do we need to clear gpu resources before repaint
+	uint32 m_unFramesToClearGPUResourcesBeforeRepaint;
+
+	// Image manager for the window
+	CImageResourceManager *m_pImageResourceManager;
+
+	bool m_bDeviceLost;
+	bool m_bAlreadyForcedRepaintAllSinceLastPaint;
+	CUtlString m_strTargetMonitor;
+	uint32 m_unSurfaceWidth, m_unSurfaceHeight;
+	uint32 m_unWindowWidth, m_unWindowHeight;
+	IUIEngine::ERenderTarget m_eRenderTarget;
+	bool m_bFixedSurfaceSize;
+	bool m_bEnforceWindowAspectRatio;
+	bool m_bUseCustomMouseCursor; // true if we draw our tenfoot cursors and not the win32 ones for this panel
+	bool m_bCursorWasVisibleLastFrame;
+	EMouseCursors m_eCursorCurrent; // current cursor to draw
+	CMouseCursorTexture *m_pMouseCursor; // contains the image data for the cursors we can display
+
+	// owner of details about the cursor state
+	CMouseCursorRender *m_pCursorRender;
+
+	// Input engine
+	CUIWindowInput *m_pInputEngine;
+
+	// the ui engine that owns us
+	CUIEngine *m_pUIEngineParent;
+	void *m_pContextPtr;
+
+	// Scale factor for all drawing sizes
+	float m_flScaleFactor;
+
+	// Min fps value the max fps can be set to for this window
+	float m_flMinFPS;
+
+	// Track last layout and paint time
+	double m_flLastLayoutAndPaintTime;
+
+	// Pointer for the surface interface created for the window
+	IUI3DSurface *m_pSurfaceInterface;
+
+	// Panel lists
+	CUtlLinkedList< CUIPanel * > m_listVisiblePanels;
+	CUtlLinkedList< CUIPanel * > m_listInvisiblePanels;
+
+	// Classes to apply to top level panels
+	CUtlVector< CPanoramaSymbol > m_vecStyleClasses;
+
+	// Panels to asynchronously add classes to
+	CUtlVector< CPanelPtr< IUIPanel > > m_vecPanelsAddClasses;
+
+	// Panels to asynchronously remove classes from
+	CUtlVector< CPanelPtr< IUIPanel > > m_vecPanelsRemoveClasses;
+
+	CFastScrollSoundManager *m_pFastScrollSoundManager;
+
+	// Mouse wheel repeat tracking
+	uint8 m_unMouseWheelUpRepeats;
+	uint8 m_unMouseWheelDownRepeats;
+	double m_flLastMouseWheelUp;
+	double m_flLastMouseWheelDown;
+
+	bool m_bInLayoutTraverse;
+	bool m_bInPaintTraverse;
+	bool m_bFinishedInitialization;
+
+	// daisy wheel usage for this window
+	enum EDaisyWheelInputType
+	{
+		eDaisyWheelInputType_KeyboardOnly,
+		eDaisyWheelInputType_GamepadOnly,
+		eDaisyWheelInputType_KeyboardAndGamePad,
+
+		eDaisyWheelInputType_MAX
+	};
+	struct DaisyWheelUsage_t
+	{
+		int nWords;
+		float flTime;
+	};
+	DaisyWheelUsage_t m_flDaisyWheelWPM[eDaisyWheelInputType_MAX];
+
+	virtual void Shutdown();
+
+	bool m_bInhibitInput;
+
+	EWindowFocusBehavior m_eFocusBehavior;
+};
+
+} // namespace panorama
+
+#endif // UITOPLEVELWINDOW_H