#include <AGUI2Menu.h>

Inheritance diagram for AGUI2Menu:

Public Types
enum	ACTIONFLAGS_ : ACTIONFLAGS { ACTIONFLAGS_NONE = 0 , ACTIONFLAGS_UP = ( 1U << ( 0 ) ) , ACTIONFLAGS_DOWN = ( 1U << ( 1 ) ) , ACTIONFLAGS_LEFT = ( 1U << ( 2 ) ) , ACTIONFLAGS_RIGHT = ( 1U << ( 3 ) ) , ACTIONFLAGS_OK = ( 1U << ( 4 ) ) , ACTIONFLAGS_CANCEL = ( 1U << ( 5 ) ) }

using	ACTIONFLAGS = TUINT32

using	ActivateCallback = void ( * )( void* a_pUserData, AGUI2MenuItem* a_pItem )

using	FocusCallback = void ( * )( void* a_pUserData, AGUI2MenuItem* a_pOldFocus, AGUI2MenuItem* a_pNewFocus )

Public Types inherited from AGUI2Element
using	t_PostRender = void ( * )()

Public Member Functions
	AGUI2Menu ()

	~AGUI2Menu ()

void	Update (TFLOAT a_fDeltaTime)

TBOOL	ProcessInputEvent (const Toshi::TInputInterface::InputEvent *a_pEvent)

TBOOL	ProcessInputCommand (AInputCommand a_eCommand, const Toshi::TInputInterface::InputEvent *a_pEvent)

void	AddMenuItem (AGUI2MenuItem &a_rMenuItem)

void	SetFocusAt (AGUI2MenuItem &a_rMenuItem)

void	ReflowChildrenVertically ()

TBOOL	TriggerButtonPress (AGUI2MenuItem &a_rMenuItem)

void	SetMenuAlpha (TFLOAT a_fAlpha, TFLOAT a_fShadowAlpha=-1.0f)

void	SetMouseStateDirty ()

AGUI2MenuItem *	GetFocusedMenuItem () const

AGUI2MenuItem *	GetHoveredMenuItem () const

AGUI2MenuItem *	GetLastMenuItem () const

void	SetCallbackUserData (void *a_pUserData)

void	SetItemActivationCallback (ActivateCallback a_fnCallback)

void	SetItemFocusCallback (FocusCallback a_fnCallback)

void	SetFocusSound (ASoundId a_eSound)

void	SetSelectSound (ASoundId a_eSound)

void	SetBackSound (ASoundId a_eSound)

void	SetNegativeSound (ASoundId a_eSound)

Public Member Functions inherited from AGUI2Element
	AGUI2Element ()

virtual	~AGUI2Element ()=default

virtual void	Tick (TFLOAT a_fDeltaTime)

virtual void	PreRender ()

virtual void	Render ()

virtual void	PostRender ()

virtual void	GetDimensions (TFLOAT &a_rWidth, TFLOAT &a_rHeight)

virtual TFLOAT	GetWidth ()

virtual TFLOAT	GetHeight ()

virtual void	SetWidth (TFLOAT a_fWidth)

virtual void	SetHeight (TFLOAT a_fHeight)

virtual void	SetDimensions (TFLOAT a_fWidth, TFLOAT a_fHeight)

virtual void	GetMins (TFLOAT &a_fX, TFLOAT &a_fY)

virtual void	GetMaxs (TFLOAT &a_fX, TFLOAT &a_fY)

virtual void	SetColour (TUINT32 a_uiColour)

virtual void	SetAlpha (TFLOAT a_fAlpha)

virtual void	SetShadowAlpha (TFLOAT a_fAlpha)

virtual void	SetFocus (TBOOL a_bFocused)

virtual TBOOL	IsPointInside (TFLOAT a_fX, TFLOAT a_fY)

void	AnchorPos (TFLOAT &a_rX, TFLOAT &a_rY, TFLOAT a_fWidth, TFLOAT a_fHeight)

void	PivotPos (TFLOAT &a_rX, TFLOAT &a_rY, TFLOAT a_fWidth, TFLOAT a_fHeight)

void	GetScreenTransform (AGUI2Transform &a_rOutTransform)

void	GetInvScreenTransform (AGUI2Transform &a_rOutTransform)

void	Show ()

void	Hide ()

void	SetInFront ()

void	SetRenderBeforeChildren ()

TBOOL	HasFlags (TUINT32 a_uiFlags) const

TBOOL	IsVisible () const

TBOOL	IsFocused () const

TBOOL	ShouldRenderBeforeChildren ()

TBOOL	IsInFront () const

TFLOAT	GetAlpha () const

void	AddChildTail (AGUI2Element &a_rElement)

void	AddChildHead (AGUI2Element &a_rElement)

void	SetTranslation (TFLOAT a_fX, TFLOAT a_fY)

void	SetTranslation (const Toshi::TVector2 &a_rTranslation)

void	SetTransform (TFLOAT a_fX, TFLOAT a_fY, float a_fRotAngle=0.0f)

void	SetAnchor (AGUI2ATTACHMENT a_eAnchor)

void	SetPivot (AGUI2ATTACHMENT a_ePivot)

void	SetAttachment (AGUI2ATTACHMENT a_eAnchor, AGUI2ATTACHMENT a_ePivot)

t_PostRender	SetPostRenderCallback (t_PostRender a_cbNewCallback)

AGUI2Transform &	GetTransform ()

AGUI2Element *	ChildBegin () const

AGUI2Element *	ChildRBegin () const

AGUI2Element *	GetNextChild (AGUI2Element *a_pCurrentChild)

AGUI2Element *	GetPrevChild (AGUI2Element *a_pCurrentChild)

void	RemoveSelf ()

void	LinkChildBefore (AGUI2Element &a_rNewChildren, AGUI2Element &a_rInsertAfter)

Public Member Functions inherited from AGUI2ElementNode
	AGUI2ElementNode ()

virtual	~AGUI2ElementNode ()

void	Unlink ()

void	LinkAfter (AGUI2ElementNode &a_rNode)

void	LinkBefore (AGUI2ElementNode &a_rNode)

TBOOL	IsLinked () const

AGUI2ElementNode *	GetNext () const

AGUI2ElementNode *	GetPrev () const

Additional Inherited Members
Public Attributes inherited from AGUI2ElementNode
friend	AGUI2Element

Static Public Attributes inherited from AGUI2Element
static TUINT32	s_uiVisibilityMask = 0xFFFFFFFF

Protected Attributes inherited from AGUI2Element
AGUI2Element *	m_pParent

AGUI2Transform	m_oTransform

AGUI2ElementNode	m_Children

AGUI2ATTACHMENT	m_eAnchor

AGUI2ATTACHMENT	m_ePivot

TFLOAT	m_fWidth

TFLOAT	m_fHeight

TUINT32	m_uiColour

TUINT32	m_eFlags

t_PostRender	m_cbPostRender

TUINT32	m_uiVisibilityMask

Protected Attributes inherited from AGUI2ElementNode
AGUI2ElementNode *	m_pNext

AGUI2ElementNode *	m_pPrev

Detailed Description

Definition at line 8 of file AGUI2Menu.h.

Member Typedef Documentation

◆ ACTIONFLAGS

using AGUI2Menu::ACTIONFLAGS = TUINT32

Definition at line 11 of file AGUI2Menu.h.

◆ ActivateCallback

using AGUI2Menu::ActivateCallback = void ( * )( void* a_pUserData, AGUI2MenuItem* a_pItem )

Definition at line 23 of file AGUI2Menu.h.

◆ FocusCallback

using AGUI2Menu::FocusCallback = void ( * )( void* a_pUserData, AGUI2MenuItem* a_pOldFocus, AGUI2MenuItem* a_pNewFocus )

Definition at line 24 of file AGUI2Menu.h.

Member Enumeration Documentation

◆ ACTIONFLAGS_

enum AGUI2Menu::ACTIONFLAGS_ : ACTIONFLAGS

Enumerator
ACTIONFLAGS_NONE
ACTIONFLAGS_UP
ACTIONFLAGS_DOWN
ACTIONFLAGS_LEFT
ACTIONFLAGS_RIGHT
ACTIONFLAGS_OK
ACTIONFLAGS_CANCEL

Definition at line 12 of file AGUI2Menu.h.

    {
        ACTIONFLAGS_NONE   = 0,
        ACTIONFLAGS_UP     = BITFLAG( 0 ),
        ACTIONFLAGS_DOWN   = BITFLAG( 1 ),
        ACTIONFLAGS_LEFT   = BITFLAG( 2 ),
        ACTIONFLAGS_RIGHT  = BITFLAG( 3 ),
        ACTIONFLAGS_OK     = BITFLAG( 4 ),
        ACTIONFLAGS_CANCEL = BITFLAG( 5 ),
    };

Constructor & Destructor Documentation

◆ AGUI2Menu()

AGUI2Menu::AGUI2Menu ( )

Definition at line 18 of file AGUI2Menu.cpp.

{
    m_fItemSpacing         = 0.0f;
    m_pDefaultFocusElement = TNULL;
    m_pCancelItem          = TNULL;
    m_pLastMenuItem        = TNULL;
    m_pFocusedMenuItem     = TNULL;
    m_eFocusSound          = soundbank::UI_MENUCLICK;
    m_eSelectSound         = soundbank::UI_MENUOK;
    m_eBackSound           = soundbank::UI_MENUBACK;
    m_eNegativeSound       = soundbank::UI_NEGATIVE;
    m_eActionFlags         = 0;
    m_Unk3                 = 0;
    m_Unk4                 = 0;
    m_fnActivateCallback   = TNULL;
    m_fnFocusCallback      = TNULL;
    m_pCallbackUserData    = TNULL;
    m_fTime                = 0.0f;
    m_bHorizontalFlow      = TFALSE;
    m_iNumMenuItems        = 0;
    m_bMouseStateDirty     = TFALSE;
    m_pHoveredMenuItem     = TNULL;
    m_eActionFlags         = 0;
    m_bFlag1               = TTRUE;
}

◆ ~AGUI2Menu()

AGUI2Menu::~AGUI2Menu ( )

Definition at line 44 of file AGUI2Menu.cpp.

45{

46}

Member Function Documentation

◆ AddMenuItem()

void AGUI2Menu::AddMenuItem ( AGUI2MenuItem & a_rMenuItem )

Definition at line 252 of file AGUI2Menu.cpp.

{
    if ( m_pLastMenuItem )
        a_rMenuItem.LinkMenuItemBefore( *m_pLastMenuItem );
    else
        m_pLastMenuItem = &a_rMenuItem;
 
    AddChildTail( a_rMenuItem );
    m_iNumMenuItems++;
}

◆ GetFocusedMenuItem()

AGUI2MenuItem * AGUI2Menu::GetFocusedMenuItem ( ) const

inline

Definition at line 46 of file AGUI2Menu.h.

46{ return m_pFocusedMenuItem; }

◆ GetHoveredMenuItem()

AGUI2MenuItem * AGUI2Menu::GetHoveredMenuItem ( ) const

inline

Definition at line 47 of file AGUI2Menu.h.

47{ return m_pHoveredMenuItem; }

◆ GetLastMenuItem()

AGUI2MenuItem * AGUI2Menu::GetLastMenuItem ( ) const

inline

Definition at line 48 of file AGUI2Menu.h.

48{ return m_pLastMenuItem; }

◆ ProcessInputCommand()

TBOOL AGUI2Menu::ProcessInputCommand	(	AInputCommand	a_eCommand,
		const Toshi::TInputInterface::InputEvent *	a_pEvent )

Definition at line 128 of file AGUI2Menu.cpp.

{
    TBOOL bHandled = TFALSE;
 
    if ( a_pEvent->GetEventType() == TInputInterface::EVENT_TYPE_GONE_DOWN ||
         a_pEvent->GetEventType() == TInputInterface::EVENT_TYPE_REPEAT ||
         EAT_ALL_INPUT_EVENTS )
    {
        bHandled = TTRUE;
 
        switch ( a_eCommand )
        {
            case AInputCommand_OK:
            case AInputCommand_Shoot:
                m_eActionFlags |= ACTIONFLAGS_OK;
                break;
            case AInputCommand_Cancel:
                m_eActionFlags |= ACTIONFLAGS_CANCEL;
                break;
            case AInputCommand_Up:
            case AInputCommand_Forward:
                m_eActionFlags |= ACTIONFLAGS_UP;
                a_pEvent->StartRepeat( 0.5f, 0.1f );
                break;
            case AInputCommand_Down:
            case AInputCommand_Backward:
                m_eActionFlags |= ACTIONFLAGS_DOWN;
                a_pEvent->StartRepeat( 0.5f, 0.1f );
                break;
            case AInputCommand_Left:
                m_eActionFlags |= ACTIONFLAGS_LEFT;
                a_pEvent->StartRepeat( 0.5f, 0.1f );
                break;
            case AInputCommand_Right:
                m_eActionFlags |= ACTIONFLAGS_RIGHT;
                a_pEvent->StartRepeat( 0.5f, 0.1f );
                break;
            default:
                bHandled = EAT_ALL_INPUT_EVENTS;
                break;
        }
    }
 
    if ( m_pFocusedMenuItem )
    {
        AGUI2MenuItem::COMMANDRESULT eCommandResult = m_pFocusedMenuItem->OnInputCommand( m_eActionFlags );
 
        if ( eCommandResult == AGUI2MenuItem::COMMANDRESULT_CANCEL )
        {
            if ( m_pCancelItem )
            {
                // Can cancel, play back sound
                ASoundManager::GetSingleton()->PlayCue( m_eBackSound );
 
                // Call handler if it's specified
                if ( m_fnActivateCallback )
                    m_fnActivateCallback( m_pCallbackUserData, m_pCancelItem );
            }
            else
            {
                // Can't cancel, play negative sound
                ASoundManager::GetSingleton()->PlayCue( m_eNegativeSound );
            }
        }
        else if ( eCommandResult == AGUI2MenuItem::COMMANDRESULT_OK )
        {
            ActivateFocusedButton();
        }
        else if ( eCommandResult == AGUI2MenuItem::COMMANDRESULT_NONE )
        {
            // If element didn't process the command, check if the menu can handle this
 
            if ( ( !m_bHorizontalFlow && m_eActionFlags & ACTIONFLAGS_UP ) ||
                 ( m_bHorizontalFlow && m_eActionFlags & ACTIONFLAGS_LEFT ) )
            {
                // Focus on next element
                AGUI2MenuItem* pNewFocused = m_pFocusedMenuItem->m_pNextMenuItem;
 
                // Skip elements that cannot be focused/activated
                while ( pNewFocused->m_pNextMenuItem && !pNewFocused->CanFocus() )
                    pNewFocused = pNewFocused->m_pNextMenuItem;
 
                if ( pNewFocused != m_pFocusedMenuItem )
                {
                    // Focus changed, play audio and call handler
 
                    ASoundManager::GetSingleton()->PlayCue( m_eFocusSound );
 
                    if ( m_fnFocusCallback )
                        m_fnFocusCallback( m_pCallbackUserData, m_pFocusedMenuItem, pNewFocused );
 
                    SetFocusAt( *pNewFocused );
                    bHandled = TTRUE;
                }
            }
            else if ( ( !m_bHorizontalFlow && m_eActionFlags & ACTIONFLAGS_DOWN ) || ( m_bHorizontalFlow && m_eActionFlags & ACTIONFLAGS_RIGHT ) )
            {
                // Focus on previous element
                AGUI2MenuItem* pNewFocused = m_pFocusedMenuItem->m_pPrevMenuItem;
 
                // Skip elements that cannot be focused/activated
                while ( pNewFocused->m_pPrevMenuItem && !pNewFocused->CanFocus() )
                    pNewFocused = pNewFocused->m_pPrevMenuItem;
 
                if ( pNewFocused != m_pFocusedMenuItem )
                {
                    // Focus changed, play audio and call handler
 
                    ASoundManager::GetSingleton()->PlayCue( m_eFocusSound );
 
                    if ( m_fnFocusCallback )
                        m_fnFocusCallback( m_pCallbackUserData, m_pFocusedMenuItem, pNewFocused );
 
                    SetFocusAt( *pNewFocused );
                    bHandled = TTRUE;
                }
            }
        }
    }
 
    m_eActionFlags = ACTIONFLAGS_NONE;
    return bHandled;
}

◆ ProcessInputEvent()

TBOOL AGUI2Menu::ProcessInputEvent ( const Toshi::TInputInterface::InputEvent * a_pEvent )

Definition at line 112 of file AGUI2Menu.cpp.

{
    if ( a_pEvent->GetEventType() == TInputInterface::EVENT_TYPE_MOVED )
    {
        // Make sure menu updates mouse state
        SetMouseStateDirty();
    }
    else if ( a_pEvent->GetEventType() == TInputInterface::EVENT_TYPE_GONE_DOWN && a_pEvent->GetDoodad() == TInputDeviceMouse::BUTTON_1 && GetHoveredMenuItem() != TNULL )
    {
        // LMB was pressed and the menu has a hovered item
        return TriggerButtonPress( *GetHoveredMenuItem() );
    }
 
    return TFALSE;
}

◆ ReflowChildrenVertically()

void AGUI2Menu::ReflowChildrenVertically ( )

Definition at line 275 of file AGUI2Menu.cpp.

{
    m_fWidth  = 0.0f;
    m_fHeight = 0.0f;
 
    TFLOAT         fOffsetY  = 0.0f;
    AGUI2MenuItem* pMenuItem = m_pLastMenuItem;
 
    if ( pMenuItem )
    {
        while ( TTRUE )
        {
            if ( pMenuItem->IsVisible() )
            {
                TFLOAT fItemWidth, fItemHeight;
                pMenuItem->GetDimensions( fItemWidth, fItemHeight );
 
                TFLOAT fItemPosY = fItemHeight * 0.5f + pMenuItem->GetFlowVisualOffset() + fOffsetY;
                pMenuItem->GetTransform().SetTranslation( 0.0f, fItemPosY );
                pMenuItem->SetAttachment( AGUI2ATTACHMENT_TOPCENTER, AGUI2ATTACHMENT_MIDDLECENTER );
 
                m_fWidth = TMath::Max( m_fWidth, fItemWidth );
                fOffsetY = fItemHeight * 0.5f + pMenuItem->GetFlowOffset() + fItemPosY + m_fItemSpacing;
            }
 
            pMenuItem = pMenuItem->m_pPrevMenuItem;
            if ( pMenuItem == m_pLastMenuItem ) break;
        }
 
        // Set focus at the last added item
        SetFocusAt( *m_pLastMenuItem );
    }
 
    // Update height
    m_fHeight = fOffsetY;
 
    // Set focus at default item if it's specified
    if ( m_pFocusedMenuItem )
        SetFocusAt( *m_pFocusedMenuItem );
 
    m_bHorizontalFlow = TFALSE;
}

◆ SetBackSound()

void AGUI2Menu::SetBackSound ( ASoundId a_eSound )

inline

Definition at line 56 of file AGUI2Menu.h.

56{ m_eBackSound = a_eSound; }

◆ SetCallbackUserData()

void AGUI2Menu::SetCallbackUserData ( void * a_pUserData )

inline

Definition at line 50 of file AGUI2Menu.h.

50{ m_pCallbackUserData = a_pUserData; }

◆ SetFocusAt()

void AGUI2Menu::SetFocusAt ( AGUI2MenuItem & a_rMenuItem )

Definition at line 263 of file AGUI2Menu.cpp.

{
    if ( a_rMenuItem.IsVisible() )
    {
        if ( m_pFocusedMenuItem )
            m_pFocusedMenuItem->OnFocusLost();
 
        m_pFocusedMenuItem = &a_rMenuItem;
        a_rMenuItem.OnFocus();
    }
}

◆ SetFocusSound()

void AGUI2Menu::SetFocusSound ( ASoundId a_eSound )

inline

Definition at line 54 of file AGUI2Menu.h.

54{ m_eFocusSound = a_eSound; }

◆ SetItemActivationCallback()

void AGUI2Menu::SetItemActivationCallback ( ActivateCallback a_fnCallback )

inline

Definition at line 51 of file AGUI2Menu.h.

51{ m_fnActivateCallback = a_fnCallback; }

◆ SetItemFocusCallback()

void AGUI2Menu::SetItemFocusCallback ( FocusCallback a_fnCallback )

inline

Definition at line 52 of file AGUI2Menu.h.

52{ m_fnFocusCallback = a_fnCallback; }

◆ SetMenuAlpha()

void AGUI2Menu::SetMenuAlpha	(	TFLOAT	a_fAlpha,
		TFLOAT	a_fShadowAlpha = -1.0f )

Definition at line 333 of file AGUI2Menu.cpp.

{
    if ( m_pLastMenuItem != TNULL )
    {
        AGUI2MenuItem* pItem = m_pLastMenuItem;
 
        while ( TTRUE )
        {
            if ( pItem->IsVisible() )
            {
                pItem->SetAlpha( a_fAlpha );
                pItem->SetShadowAlpha( ( a_fShadowAlpha == -1.0f ) ? a_fAlpha : a_fShadowAlpha );
            }
 
            pItem = pItem->m_pPrevMenuItem;
            if ( pItem == m_pLastMenuItem ) break;
        }
    }
 
    AGUI2Element::SetAlpha( a_fAlpha );
}

◆ SetMouseStateDirty()

void AGUI2Menu::SetMouseStateDirty ( )

inline

Definition at line 44 of file AGUI2Menu.h.

44{ m_bMouseStateDirty = TTRUE; }

◆ SetNegativeSound()

void AGUI2Menu::SetNegativeSound ( ASoundId a_eSound )

inline

Definition at line 57 of file AGUI2Menu.h.

57{ m_eNegativeSound = a_eSound; }

◆ SetSelectSound()

void AGUI2Menu::SetSelectSound ( ASoundId a_eSound )

inline

Definition at line 55 of file AGUI2Menu.h.

55{ m_eSelectSound = a_eSound; }

◆ TriggerButtonPress()

TBOOL AGUI2Menu::TriggerButtonPress ( AGUI2MenuItem & a_rMenuItem )

Definition at line 318 of file AGUI2Menu.cpp.

{
    m_eActionFlags |= ACTIONFLAGS_OK;
    AGUI2MenuItem::COMMANDRESULT eCommandResult = a_rMenuItem.OnInputCommand( m_eActionFlags );
    m_eActionFlags                              = ACTIONFLAGS_NONE;
 
    if ( eCommandResult == AGUI2MenuItem::COMMANDRESULT_OK )
    {
        ActivateFocusedButton();
        return TTRUE;
    }
 
    return TFALSE;
}

◆ Update()

void AGUI2Menu::Update ( TFLOAT a_fDeltaTime )

Definition at line 48 of file AGUI2Menu.cpp.

{
    if ( m_bMouseStateDirty )
    {
        AGUI2Transform oElementInvTransform;
 
        if ( m_pLastMenuItem != TNULL )
        {
            TVector2 vecCursorPos = AGUI2::GetMouseCursor().GetCursorPos();
            m_pHoveredMenuItem    = TNULL;
 
            AGUI2MenuItem* pItem = m_pLastMenuItem;
 
            while ( TTRUE )
            {
                if ( pItem->IsVisible() )
                {
                    // Get inverse transform of the current UI element
                    pItem->GetInvScreenTransform( oElementInvTransform );
 
                    // Get cursor position that is relative to the UI element
                    TVector2 vecElementRelCursorPos;
                    oElementInvTransform.Transform( vecElementRelCursorPos, vecCursorPos );
 
                    if ( pItem->IsPointInside( vecElementRelCursorPos.x, vecElementRelCursorPos.y ) )
                    {
                        if ( m_pFocusedMenuItem != pItem )
                        {
                            SetFocusAt( *pItem );
                            ASoundManager::GetSingleton()->PlayCue( m_eFocusSound );
                        }
 
                        m_pHoveredMenuItem = pItem;
                        break;
                    }
                }
 
                pItem = pItem->m_pPrevMenuItem;
                if ( pItem == m_pLastMenuItem ) break;
            }
        }
 
        m_bMouseStateDirty = TFALSE;
    }
 
    if ( m_pLastMenuItem != TNULL )
    {
        AGUI2MenuItem* pItem = m_pLastMenuItem;
 
        while ( TTRUE )
        {
            if ( pItem->IsVisible() )
            {
                pItem->OnUpdate( a_fDeltaTime );
            }
 
            pItem = pItem->m_pPrevMenuItem;
            if ( pItem == m_pLastMenuItem ) break;
        }
    }
 
    m_fTime += a_fDeltaTime;
}

The documentation for this class was generated from the following files:

D:/_dev/OpenBarnyard/Source/OpenBarnyard/Source/GUI/AGUI2Menu.h
D:/_dev/OpenBarnyard/Source/OpenBarnyard/Source/GUI/AGUI2Menu.cpp

Public Types

Public Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ACTIONFLAGS

◆ ActivateCallback

◆ FocusCallback

Member Enumeration Documentation

◆ ACTIONFLAGS_

Constructor & Destructor Documentation

◆ AGUI2Menu()

◆ ~AGUI2Menu()

Member Function Documentation

◆ AddMenuItem()

◆ GetFocusedMenuItem()

◆ GetHoveredMenuItem()

◆ GetLastMenuItem()

◆ ProcessInputCommand()

◆ ProcessInputEvent()

◆ ReflowChildrenVertically()

◆ SetBackSound()

◆ SetCallbackUserData()

◆ SetFocusAt()

◆ SetFocusSound()

◆ SetItemActivationCallback()

◆ SetItemFocusCallback()

◆ SetMenuAlpha()

◆ SetMouseStateDirty()

◆ SetNegativeSound()

◆ SetSelectSound()

◆ TriggerButtonPress()

◆ Update()