579 lines
24 KiB
C++
579 lines
24 KiB
C++
//=========== Copyright Valve Corporation, All rights reserved. ===============//
|
|
//
|
|
// Purpose:
|
|
//=============================================================================//
|
|
|
|
#ifndef IUIPANEL_H
|
|
#define IUIPANEL_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "panoramatypes.h"
|
|
#include "panoramasymbol.h"
|
|
#include "iuirenderengine.h"
|
|
#include "layout/stylefiletypes.h"
|
|
#include "layout/uilength.h"
|
|
#include "tier1/utlstring.h"
|
|
|
|
namespace panorama
|
|
{
|
|
|
|
class CLayoutFile;
|
|
class IUIPanelStyle;
|
|
class IUIPanelClient;
|
|
class IUIWindow;
|
|
class IUIImageManager;
|
|
class IUI3DSurface;
|
|
class IUIEvent;
|
|
class IUIScrollBar;
|
|
typedef panorama::IUIPanelClient * ClientPanelPtr_t;
|
|
typedef CUtlVector< panorama::IUIEvent * > VecUIEvents_t;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Used to provide property info to debugger for output
|
|
//-----------------------------------------------------------------------------
|
|
struct DebugPropertyOutput_t
|
|
{
|
|
DebugPropertyOutput_t() {}
|
|
DebugPropertyOutput_t( const char *pchName, const char *pchValue ) : m_strName( pchName ), m_strValue( pchValue ) {}
|
|
|
|
CUtlString m_strName;
|
|
CUtlString m_strValue;
|
|
};
|
|
|
|
|
|
enum ScrollBehavior_t
|
|
{
|
|
SCROLL_BEHAVIOR_SCROLL_MINIMUM_DISTANCE = 0,
|
|
SCROLL_BEHAVIOR_SCROLL_TO_TOPLEFT_EDGE,
|
|
SCROLL_BEHAVIOR_SCROLL_TO_BOTTOMRIGHT_EDGE,
|
|
SCROLL_BEHAVIOR_SCROLL_TO_CENTER,
|
|
|
|
SCROLL_BEHAVIOR_DEFAULT = SCROLL_BEHAVIOR_SCROLL_MINIMUM_DISTANCE,
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Basic panel interface exposing operations used inside of panorama, rather
|
|
// than operations that are part of building/laying out controls in the panorama_client module
|
|
//-----------------------------------------------------------------------------
|
|
class IUIPanel
|
|
{
|
|
public:
|
|
virtual ~IUIPanel() {}
|
|
|
|
// Initialize panel
|
|
virtual void Initialize( IUIWindow *window, IUIPanel *parent, const char *pchID, uint32 ePanelFlags ) = 0;
|
|
|
|
// Initialize a cloned panel from ourself
|
|
virtual void InitClonedPanel( IUIPanel *pClone ) = 0;
|
|
|
|
// Do panel2d event type registrations
|
|
virtual void RegisterEventHandlersOnPanel2DType( CPanoramaSymbol symPanelType ) = 0;
|
|
|
|
// Shutdown panel, should only happen right before actual deletion
|
|
virtual void Shutdown() = 0;
|
|
|
|
// Fire panel loaded event and mark us as now loaded, images and other panels may call this late
|
|
virtual void FirePanelLoadedEvent() = 0;
|
|
|
|
// Gets client type pointer value
|
|
virtual void SetClientPtr( panorama::IUIPanelClient *pPtr ) = 0;
|
|
virtual panorama::IUIPanelClient * ClientPtr() const = 0;
|
|
|
|
// Set panel id
|
|
virtual void SetID( const char *pchID ) = 0;
|
|
|
|
// Get panel id
|
|
virtual const char *GetID() const = 0;
|
|
|
|
// Get panel type, which really calls back into client panel object
|
|
virtual CPanoramaSymbol GetPanelType() const = 0;
|
|
|
|
// Check for valid panel id
|
|
virtual bool BHasID() const = 0;
|
|
|
|
// sets & loads the layout file for this panel
|
|
virtual bool BLoadLayout( const char *pchFile, bool bOverrideExisting = false, bool bPartialLayout = false ) = 0;
|
|
|
|
// sets & loads the layout for this panel
|
|
virtual bool BLoadLayoutFromString( const char *pchXMLString, bool bOverrideExisting = false, bool bPartialLayout = false ) = 0;
|
|
|
|
// sets loads the layout file for this panel, asynchronously supporting remote http:// paths
|
|
virtual void LoadLayoutAsync( const char *pchFile, bool bOverrideExisting = false, bool bPartialLayout = false ) = 0;
|
|
|
|
// loads the layout file for this panel, asynchronously supporting remote http:// paths in css within
|
|
virtual void LoadLayoutFromStringAsync( const char *pchXMLString, bool bOverrideExisting, bool bPartialLayout = false ) = 0;
|
|
|
|
// Check if the panel has loaded layout
|
|
virtual bool IsLoaded() const = 0;
|
|
|
|
// Set panel's immediate parent
|
|
virtual void SetParent( panorama::IUIPanel *pParent ) = 0;
|
|
|
|
// Get panel's immediate parent
|
|
virtual panorama::IUIPanel *GetParent() const = 0;
|
|
|
|
// Get panel's parent window
|
|
virtual panorama::IUIWindow *GetParentWindow() const = 0;
|
|
|
|
// Set panel visibility
|
|
virtual void SetVisible( bool bVisible ) = 0;
|
|
|
|
// Is the panel visible (not accounting for opacity)
|
|
virtual bool BIsVisible() const = 0;
|
|
|
|
// Is the panel transparent (may be 'visible' and affect layout, but fully transparent)
|
|
virtual bool BIsTransparent() const = 0;
|
|
|
|
// Set the layout file this panel is loaded from based on a parent, shouldn't need this directly normally
|
|
virtual void SetLayoutLoadedFromParent( panorama::IUIPanel *pParent ) = 0;
|
|
|
|
// Returns the layout file for this panel (ie, the one it loaded if any)
|
|
virtual panorama::CPanoramaSymbol GetLayoutFile() const = 0;
|
|
|
|
// Returns layout file that loaded us which may have been loaded by an ancestor rather than direct parent
|
|
virtual panorama::CPanoramaSymbol GetLayoutFileLoadedFrom() const = 0;
|
|
|
|
// Get the current reload count for the panel's layout file - can be used to detect when a reload has occurred
|
|
// Returns -1 if no layout file.
|
|
virtual int GetLayoutFileReloadCount() const = 0;
|
|
|
|
// searches only immediate children
|
|
virtual panorama::IUIPanel *FindChild( const char *pchID ) = 0;
|
|
|
|
// searches all children even outside layout file scope
|
|
virtual panorama::IUIPanel *FindChildTraverse( const char *pchID ) = 0;
|
|
|
|
// searches any children created from our layout file
|
|
virtual IUIPanel *FindChildInLayoutFile( const char *pchID ) = 0;
|
|
|
|
// searches any panel created from our layout file (so parents or children!)
|
|
virtual IUIPanel *FindPanelInLayoutFile( const char *pchID ) = 0;
|
|
|
|
// Check if this panel is a descendant of the passed panel
|
|
virtual bool IsDescendantOf( const panorama::IUIPanel *pPanel ) const = 0;
|
|
|
|
// Remove and delete all children from panel
|
|
virtual void RemoveAndDeleteChildren() = 0;
|
|
|
|
// Remove and delete all children matching type
|
|
virtual void RemoveAndDeleteChildrenOfType( CPanoramaSymbol symPanelType ) = 0;
|
|
|
|
// Child access
|
|
virtual int GetChildCount() const = 0;
|
|
virtual IUIPanel *GetChild( int i ) const = 0;
|
|
virtual IUIPanel *GetFirstChild() const = 0;
|
|
virtual IUIPanel *GetLastChild() const = 0;
|
|
|
|
// Return index of child in creation/panel vector order (also default tab order)
|
|
virtual int GetChildIndex( const IUIPanel *pChild ) const = 0;
|
|
|
|
// Get child count of specific type
|
|
virtual uint32 GetChildCountOfType( CPanoramaSymbol symPanelType ) = 0;
|
|
|
|
// For special children to be rendered in debugger
|
|
virtual int GetHiddenChildCount() const = 0;
|
|
virtual IUIPanel *GetHiddenChild( int i ) = 0;
|
|
|
|
// Find ancestor with matching id
|
|
virtual IUIPanel *FindAncestor( const char *pchID ) = 0;
|
|
|
|
// Set the panels repaint state
|
|
virtual void SetRepaint( panorama::EPanelRepaint eRepaintNeeded ) = 0;
|
|
|
|
// Check if we should draw this child
|
|
virtual bool BShouldDrawChild( panorama::IUIPanel *pChild ) = 0;
|
|
|
|
// Apply layout file to panel
|
|
virtual bool BAppyLayoutFile( panorama::CLayoutFile *pLayoutFile, CUtlVector< panorama::IUIPanel * > *pvecExistingPanels ) = 0;
|
|
|
|
// Enable or disable background movies on panel
|
|
virtual void EnableBackgroundMovies( bool bEnabled ) = 0;
|
|
|
|
// Access panel's style information
|
|
virtual panorama::IUIPanelStyle * AccessIUIStyle() = 0;
|
|
|
|
// Returns potentially dirty styles data, use for setting during initial construction/setup - or if you want to explicitly ignore transitions, but never for getting and generally not for setting!
|
|
virtual panorama::IUIPanelStyle *AccessIUIStyleDirty() = 0;
|
|
|
|
// Apply styles on the panel, resolving them all fully and updating actual panel style
|
|
virtual void ApplyStyles( bool bTraverse ) = 0;
|
|
|
|
// Set that we want an on styles changed event when styles are applied even if styles aren't actually dirty
|
|
virtual void SetOnStylesChangedNeeded() = 0;
|
|
|
|
// Access all children directly
|
|
virtual CUtlVector<panorama::IUIPanel *> const &AccessChildren() = 0;
|
|
|
|
// Measure self and children. First pass of layout
|
|
virtual void DesiredLayoutSizeTraverse( float flMaxWidth, float flMaxHeight ) = 0;
|
|
virtual void DesiredLayoutSizeTraverse( float *pflDesiredWidth, float *pflDesiredHeight, float flMaxWidth, float flMaxHeight, bool bFinalDimensions ) = 0;
|
|
|
|
// Tell us what your content size is
|
|
virtual void OnContentSizeTraverse( float *pflContentWidth, float *pflContentHeight, float flMaxWidth, float flMaxHeight, bool bFinalDimensions ) = 0;
|
|
|
|
// Arrange children. Second pass of layout
|
|
virtual void LayoutTraverse( float x, float y, float flFinalWidth, float flFinalHeight ) = 0;
|
|
|
|
// Tell us how to actually layout children
|
|
virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight ) = 0;
|
|
|
|
// called by flowing and custom layout passes to set position. Will properly handle transition being applied with styles
|
|
virtual void SetPositionFromLayoutTraverse( CUILength x, CUILength y, CUILength z ) = 0;
|
|
|
|
// methods to invalid certain parts of layout
|
|
virtual void InvalidateSizeAndPosition() = 0;
|
|
virtual void InvalidatePosition() = 0;
|
|
virtual void SetActiveSizeAndPositionTransition() = 0;
|
|
virtual void SetActivePositionTransition() = 0;
|
|
virtual bool IsSizeValid() = 0;
|
|
virtual bool IsPositionValid() = 0;
|
|
virtual bool IsChildSizeValid() = 0;
|
|
virtual bool IsChildPositionValid() = 0;
|
|
virtual bool IsSizeTransitioning() = 0;
|
|
virtual bool IsPositionTransitioning() = 0;
|
|
virtual bool IsChildPositionTransitioning() = 0;
|
|
virtual bool IsChildSizeTransitioning() = 0;
|
|
virtual void TransitionPositionApplied( bool bImmediate ) = 0;
|
|
|
|
// size getters
|
|
virtual float GetDesiredLayoutWidth() const = 0;
|
|
virtual float GetDesiredLayoutHeight() const = 0;
|
|
|
|
// Content size is what our contents actually take up, not accounting for fixed/relative
|
|
// size set on us in styles which affect desired layout size
|
|
virtual float GetContentWidth() const = 0;
|
|
virtual float GetContentHeight() const = 0;
|
|
|
|
// Actual size is the size given to the panel after layout, hopefully as big as its desired size.
|
|
// Actual size does NOT include margins (which are really in the parent).
|
|
virtual float GetActualLayoutWidth() const = 0;
|
|
virtual float GetActualLayoutHeight() const = 0;
|
|
|
|
// Render size is the size of the content for rendering, this is either the actual layout size, or if
|
|
// that is smaller than the content size + padding then it's the content size + padding.
|
|
virtual float GetActualRenderWidth() = 0;
|
|
virtual float GetActualRenderHeight() = 0;
|
|
|
|
// Offset will include position, alignment, and margin adjustments
|
|
virtual float GetActualXOffset() const = 0;
|
|
virtual float GetActualYOffset() const = 0;
|
|
|
|
// returns offset for drawing minus position
|
|
virtual float GetRawActualXOffset() const = 0;
|
|
virtual float GetRawActualYOffset() const = 0;
|
|
|
|
// Offset to apply to contents for scrolling
|
|
virtual float GetContentsYScrollOffset() const = 0;
|
|
virtual float GetContentsXScrollOffset() const = 0;
|
|
virtual float GetContentsYScrollOffsetTarget() const = 0;
|
|
virtual float GetContentsXScrollOffsetTarget() const = 0;
|
|
virtual double GetContentsXScrollTransitionStart() const = 0;
|
|
virtual double GetContentsYScrollTransitionStart() const = 0;
|
|
virtual float GetInterpolatedXScrollOffset() = 0;
|
|
virtual float GetInterpolatedYScrollOffset() = 0;
|
|
|
|
// Can the panel scroll further?
|
|
virtual bool BCanScrollUp() = 0;
|
|
virtual bool BCanScrollDown() = 0;
|
|
virtual bool BCanScrollLeft() = 0;
|
|
virtual bool BCanScrollRight() = 0;
|
|
|
|
// style class management
|
|
virtual void AddClass( const char *pchName ) = 0;
|
|
virtual void AddClass( CPanoramaSymbol symbol ) = 0;
|
|
virtual void AddClasses( const char *pchName ) = 0;
|
|
virtual void AddClasses( CPanoramaSymbol *pSymbols, uint cSymbols ) = 0;
|
|
virtual void RemoveClass( const char *pchName ) = 0;
|
|
virtual void RemoveClass( CPanoramaSymbol symName ) = 0;
|
|
virtual void RemoveClasses( const CPanoramaSymbol *pSymbols, uint cSymbols ) = 0;
|
|
virtual void RemoveClasses( const char *pchName ) = 0;
|
|
virtual void RemoveAllClasses() = 0;
|
|
virtual const CUtlVector< CPanoramaSymbol > &GetClasses() const = 0;
|
|
virtual bool BHasClass( const char *pchName ) = 0;
|
|
virtual bool BHasClass( CPanoramaSymbol symName ) = 0;
|
|
virtual bool BAscendantHasClass( const char *pchName ) = 0;
|
|
virtual bool BAscendantHasClass( CPanoramaSymbol symName ) = 0;
|
|
virtual void ToggleClass( const char *pchName ) = 0;
|
|
virtual void ToggleClass( CPanoramaSymbol symName ) = 0;
|
|
virtual void SetHasClass( const char *pchName, bool bHasClass ) = 0;
|
|
virtual void SetHasClass( CPanoramaSymbol symName, bool bHasClass ) = 0;
|
|
virtual void SwitchClass( const char *pchAttribute, const char *pchName ) = 0;
|
|
virtual void SwitchClass( const char *pchAttribute, CPanoramaSymbol symName ) = 0;
|
|
|
|
virtual bool BAcceptsInput() = 0;
|
|
virtual void SetAcceptsInput( bool bAllowInput ) = 0;
|
|
virtual bool BAcceptsFocus() const = 0;
|
|
virtual void SetAcceptsFocus( bool bAllowFocus ) = 0;
|
|
// true if it would normally sink input, but may not right now if disabled
|
|
virtual bool BCanAcceptInput() = 0;
|
|
virtual void SetDefaultFocus( const char *pchChildID ) = 0;
|
|
virtual const char *GetDefaultFocus() const = 0;
|
|
virtual void SetDisableFocusOnMouseDown( bool bDisable ) = 0;
|
|
virtual bool BFocusOnMouseDown() = 0;
|
|
|
|
// Should this panel be the top of an input hierarchy and keep track of focus within itself, not losing focus when a panel in some
|
|
// other hierarchy changes focus? Use this for panels that are peers like friends vs browser vs mainmenu in tenfoot
|
|
virtual bool BTopOfInputContext() = 0;
|
|
virtual void SetTopOfInputContext( bool bIsTopOfInputContext ) = 0;
|
|
|
|
virtual IUIPanel *GetParentInputContext() = 0;
|
|
|
|
// Get the default input focus child within this panel, may be null
|
|
virtual IUIPanel *GetDefaultInputFocus() = 0;
|
|
|
|
// Set focus to this panel, which will auto-scroll it into full view as well if parent has overflow: scroll
|
|
virtual bool SetFocus() = 0;
|
|
|
|
// Set the focus to this panel in it's input context, but do not make the context change if some other context currently
|
|
// has focus
|
|
virtual bool UpdateFocusInContext() = 0;
|
|
|
|
// Set the focus in response to receiving hover (on panels that a parent sets childfocusonhover), this will
|
|
// never scroll the parent.
|
|
virtual bool SetFocusDueToHover() = 0;
|
|
|
|
virtual void SetInputContextFocus() = 0;
|
|
|
|
// retrieve the style flags (map to CSS psuedo-classes) for this panel
|
|
virtual uint GetStyleFlags() const = 0;
|
|
virtual void AddStyleFlag( EStyleFlags eStyleFlag ) = 0;
|
|
virtual void RemoveStyleFlag( EStyleFlags eStyleFlag ) = 0;
|
|
virtual bool IsInspected() const = 0;
|
|
virtual bool BHasHoverStyle() const = 0;
|
|
virtual void SetSelected( bool bSelected ) = 0;
|
|
virtual bool IsSelected() const = 0;
|
|
virtual bool BHasKeyFocus() const = 0;
|
|
virtual bool BHasDescendantKeyFocus() const = 0;
|
|
virtual bool IsLayoutLoading() const = 0;
|
|
|
|
// enable/disable
|
|
virtual void SetEnabled( bool bEnabled ) = 0;
|
|
virtual bool IsEnabled() const = 0;
|
|
|
|
virtual bool IsActivationEnabled() = 0;
|
|
|
|
// Set activation disabled on this panel, input/focus still generally work, but Activate events won't be handled, useful to prevent a button
|
|
// being clicked when out of focus, but leave it able to be focused for later activation or such
|
|
virtual void SetActivationEnabled( bool bEnabled ) = 0;
|
|
|
|
// Set all our immediate children enabled/disabled
|
|
virtual void SetAllChildrenActivationEnabled( bool bEnabled ) = 0;
|
|
|
|
// Enable/disable hit testing of this panel, you may want a parent that is never hit test that has a large region, but clicks
|
|
// just pass through to other things behind it. Children may still hit test.
|
|
virtual void SetHitTestEnabled( bool bEnabled ) = 0;
|
|
virtual bool BHitTestEnabled() const = 0;
|
|
virtual void SetHitTestEnabledTraverse( bool bEnabled ) = 0;
|
|
|
|
// drag/drop
|
|
virtual void SetDraggable( bool bEnabled ) = 0;
|
|
virtual bool IsDraggable() const = 0;
|
|
|
|
// the input namespace to use for this panel
|
|
virtual const char *GetInputNamespace() const = 0;
|
|
|
|
virtual void SetInputNamespace( const char *pchNamespace ) = 0;
|
|
|
|
// Mark styles dirty for the panel
|
|
virtual void MarkStylesDirty( bool bIncludeChildren ) = 0;
|
|
|
|
// Check if styles are dirty for the panel
|
|
virtual bool BStylesDirty() const = 0;
|
|
|
|
// Check if styles are possibly dirty for any of our children
|
|
virtual bool BChildStylesDirty() = 0;
|
|
|
|
// Parse panel event for this panel
|
|
virtual bool BParsePanelEvent( CPanoramaSymbol symPanelEvent, const char *pchValue ) = 0;
|
|
|
|
// Check if panel event is set on panel for event type
|
|
virtual bool BIsPanelEventSet( CPanoramaSymbol symPanelEvent ) = 0;
|
|
|
|
// Check if the event is a valid panel event type
|
|
virtual bool BIsPanelEvent( CPanoramaSymbol symPanelEvent ) const = 0;
|
|
|
|
// Dispatch the panel event if the panel has something set for it now
|
|
virtual bool DispatchPanelEvent( CPanoramaSymbol symPanelEvent ) = 0;
|
|
|
|
// Get the containing panel for this panels javascript context
|
|
virtual panorama::IUIPanel *GetJavaScriptContextParent() const = 0;
|
|
|
|
// Accessor for appropriate image manager for panel
|
|
virtual panorama::IUIImageManager* UIImageManager() = 0;
|
|
|
|
// Accessor for appropriate 3d surface interface for this panel
|
|
virtual panorama::IUIRenderEngine *UIRenderEngine() = 0;
|
|
|
|
// Explicit call to paint the panel and all it's children, normally called internally by window
|
|
virtual void PaintTraverse() = 0;
|
|
|
|
// Tab index setting
|
|
virtual void SetTabIndex( float flTabIndex ) = 0;
|
|
virtual float GetTabIndex() const = 0;
|
|
virtual void SetSelectionPosition( float flXPos, float flYPos ) = 0;
|
|
virtual void SetSelectionPositionX( float flXPos ) = 0;
|
|
virtual void SetSelectionPositionY( float flYPos ) = 0;
|
|
virtual float GetSelectionPositionX() const = 0;
|
|
virtual float GetSelectionPositionY() const = 0;
|
|
|
|
// Tab index and selection position backing values rather than interpreted (ie. will return k_flSelectionPosAuto rather than the auto-calculated value)
|
|
virtual float GetTabIndex_Raw() const = 0;
|
|
virtual float GetSelectionPositionX_Raw() const = 0;
|
|
virtual float GetSelectionPositionY_Raw() const = 0;
|
|
|
|
// Tell the panel to set focus to the next panel in specified movement/order method
|
|
virtual bool SetFocusToNextPanel( int nRepeats, EFocusMoveDirection moveType, bool bAllowWrap, float flTabIndexCurrent, float flXPosCurrent, float flYPosCurrent, float flXStart, float flYStart ) = 0;
|
|
virtual bool SetInputFocusToFirstOrLastChildInFocusOrder( EFocusMoveDirection moveType, float flXStart, float flYStart ) = 0;
|
|
|
|
// Is this panel a selection pos repeat boundary?
|
|
virtual bool BSelectionPosVerticalBoundary() = 0;
|
|
virtual bool BSelectionPosHorizontalBoundary() = 0;
|
|
|
|
// controls if clicking on an unfocused panel should set focus
|
|
virtual void SetChildFocusOnHover( bool bEnable ) = 0;
|
|
virtual bool GetChildFocusOnHover() = 0;
|
|
|
|
// Panel scrolling
|
|
virtual void ScrollToTop() = 0;
|
|
virtual void ScrollToBottom() = 0;
|
|
virtual void ScrollToLeftEdge() = 0;
|
|
virtual void ScrollToRightEdge() = 0;
|
|
virtual void ScrollParentToMakePanelFit( ScrollBehavior_t behavior = SCROLL_BEHAVIOR_DEFAULT, bool bImmediateScroll = false ) = 0;
|
|
virtual void ScrollToFitRegion( float x0, float x1, float y0, float y1, ScrollBehavior_t behavior = SCROLL_BEHAVIOR_DEFAULT, bool bDirectParentScrollOnly = false, bool bImmediateScroll = false ) = 0;
|
|
virtual bool BCanSeeInParentScroll() = 0;
|
|
|
|
virtual void OnScrollPositionChanged() = 0;
|
|
virtual void SetSendChildScrolledIntoViewEvents( bool bSendChildReadyEvents ) = 0; // this must be enabled on your parent for ScrolledIntoView events to fire and IsScrolledIntoView state to be set
|
|
virtual bool OnCheckChildrenScrolledIntoView() = 0;
|
|
virtual void FireScrolledIntoViewEvent() = 0;
|
|
virtual void FireScrolledOutOfViewEvent() = 0;
|
|
virtual bool IsScrolledIntoView() const = 0;
|
|
|
|
// Direct child management
|
|
virtual void SortChildren( int( __cdecl *pfnCompare )(const ClientPanelPtr_t *, const ClientPanelPtr_t *) ) = 0;
|
|
|
|
// child management, use with caution! normally always managed internally.
|
|
virtual void AddChild( IUIPanel *pChild ) = 0;
|
|
|
|
// child management, use with caution! normally always managed internally. Returns child index we inserted at.
|
|
virtual int AddChildSorted( bool( __cdecl *pfnLessFunc )(ClientPanelPtr_t const &p1, ClientPanelPtr_t const &p2), IUIPanel *pChild ) = 0;
|
|
|
|
// child management, use with caution! normally always managed internally.
|
|
virtual void RemoveChild( IUIPanel *pChild ) = 0;
|
|
|
|
// Move child after another child
|
|
virtual void MoveChildAfter( IUIPanel *pChildToMove, IUIPanel *pBefore ) = 0;
|
|
|
|
// Move child before another child
|
|
virtual void MoveChildBefore( IUIPanel *pChildToMove, IUIPanel *pAfter ) = 0;
|
|
|
|
virtual void SetMouseCanActivate( EMouseCanActivate eMouseCanActivate, const char *pchOptionalParent = NULL ) = 0;
|
|
virtual EMouseCanActivate GetMouseCanActivate() = 0;
|
|
virtual IUIPanel *FindParentForMouseCanActivate() = 0;
|
|
|
|
virtual bool BReloadLayout( CPanoramaSymbol symPath ) = 0;
|
|
|
|
virtual void ReloadStyleFileTraverse( CPanoramaSymbol symPath ) = 0;
|
|
|
|
virtual bool BHasOnActivateEvent() = 0;
|
|
virtual bool BHasOnMouseActivateEvent() = 0;
|
|
|
|
// Called to ask us to setup object template for Javascript, you can implement this in a child class and then call
|
|
// the base method (so all the normal panel2d stuff gets exposed), plus call the various RegisterJS helpers yourself
|
|
// to expose additional panel type specific data/methods.
|
|
virtual void SetupJavascriptObjectTemplate() = 0;
|
|
|
|
virtual void SetLayoutFile( CPanoramaSymbol symLayoutFile ) = 0;
|
|
|
|
// Low level build matching style list for debugger use
|
|
virtual bool BBuildMatchingStyleList( CUtlVector< CascadeStyleFileInfo_t > *pvecStyles ) = 0;
|
|
|
|
// Getter for panel attributes
|
|
virtual int GetAttribute( const char *pchAttrName, int nDefaultValue ) = 0;
|
|
|
|
// Getter for panel attributes
|
|
virtual const char *GetAttribute( const char *pchAttrName, const char * pchDefaultValue ) = 0;
|
|
|
|
// Getter for panel attributes
|
|
virtual uint32 GetAttribute( const char *pchAttrName, uint32 unDefaultValue ) = 0;
|
|
|
|
// Getter for panel attributes
|
|
virtual uint64 GetAttribute( const char *pchAttrName, uint64 unDefaultValue ) = 0;
|
|
|
|
// Setter for panel attributes
|
|
virtual void SetAttribute( const char *pchAttrName, int nValue ) = 0;
|
|
|
|
// Setter for panel attributes
|
|
virtual void SetAttribute( const char *pchAttrName, const char * pchValue ) = 0;
|
|
|
|
// Setter for panel attributes
|
|
virtual void SetAttribute( const char *pchAttrName, uint32 unValue ) = 0;
|
|
|
|
// Setter for panel attributes
|
|
virtual void SetAttribute( const char *pchAttrName, uint64 unValue ) = 0;
|
|
|
|
// Set animation property on panel
|
|
virtual void SetAnimation( const char *pchAnimationName, float flDuration, float flDelay, EAnimationTimingFunction eTimingFunc, EAnimationDirection eDirection, float flIterations ) = 0;
|
|
|
|
// Force an immediate update of the visibility list on our window for our current visibility
|
|
virtual void UpdateVisibility( bool bUseDirtyStyles ) = 0;
|
|
|
|
// Base class implementation for valid XML properties to be set
|
|
virtual bool BSetProperty( CPanoramaSymbol symName, const char *pchValue ) = 0;
|
|
|
|
// Builds a string of properties and values to display in the debugger
|
|
virtual void GetDebugPropertyInfo( CUtlVector< DebugPropertyOutput_t *> *pvecProperties ) = 0;
|
|
|
|
// Populates a vector with all immediate children matching a class
|
|
virtual void FindChildrenWithClass( const char *pchClass, CUtlVector<IUIPanel *> &vecMatchingChildren ) = 0;
|
|
|
|
// Populates a vector with all children matching a class
|
|
virtual void FindChildrenWithClassTraverse( const char *pchClass, CUtlVector<IUIPanel *> &vecMatchingChildren ) = 0;
|
|
|
|
// Play focus change sound accounting for fast scroll volume fade effects, etc
|
|
virtual void PlayFocusChangeSound( int nRepeats, float flPan ) = 0;
|
|
|
|
// Clear all panel events
|
|
virtual void ClearPanelEvents() = 0;
|
|
|
|
// Clear specific panel event
|
|
virtual void ClearPanelEvents( CPanoramaSymbol symPanelEvent ) = 0;
|
|
|
|
// panel events
|
|
virtual void SetPanelEvent( CPanoramaSymbol symPanelEvent, IUIEvent *pEvent ) = 0;
|
|
virtual void SetPanelEvent( CPanoramaSymbol symPanelEvent, VecUIEvents_t *pEvents ) = 0;
|
|
|
|
// Should analog stick be able to scroll this panel?
|
|
virtual bool BEnableAnalogStickScrolling() = 0;
|
|
|
|
// Set mouse tracking state
|
|
virtual void SetMouseTracking( bool bState ) = 0;
|
|
|
|
// Should only be called in the very limited cases where we are creating scrollbars within a layout pass,
|
|
// exposed for HTML but should really only be used inside UIPanel normally
|
|
virtual void SetInScrollbarConstruction( bool bConstructing ) = 0;
|
|
|
|
// Get the scrollbar for this panel if it exists
|
|
virtual IUIScrollBar *GetVerticalScrollBar() = 0;
|
|
virtual IUIScrollBar *GetHorizontalScrollBar() = 0;
|
|
|
|
// Get panel events set on panel
|
|
virtual VecUIEvents_t * GetPanelEvents( CPanoramaSymbol symEvent ) = 0;
|
|
|
|
// Has this panel ever been layed out
|
|
virtual bool BHasBeenLayedOut() const = 0;
|
|
|
|
// Callback that styles have cleaned up some transitions, we should update cached state about what styles are present
|
|
virtual void OnStyleTransitionsCleanup() = 0;
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
virtual void Validate( CValidator &validator, const char *pchName ) = 0;
|
|
#endif
|
|
};
|
|
|
|
}
|
|
#endif // IUIPANEL_H
|