300 lines
10 KiB
C++
300 lines
10 KiB
C++
//=========== 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
|