radialquickbarmenu.c

Go to the documentation of this file.

enum RadialQuickbarCategory
{
    DEFAULT,
    SPECIALIZED_LIGHTS
}
 
class RadialQuickbarItem
{
    protected bool                  m_IsLightSourceExtra;
    protected bool                  m_IsNVG;
    protected int                   m_Id;
    protected int                   m_Category;
    protected int                   m_CategorySwitchID;
    protected EntityAI              m_Item;
    protected string                m_ItemName;
    
    //radial menu
    protected Widget            m_RadialMenuSelector;
    protected Widget            m_RadialMenuItemCard;
    
    void RadialQuickbarItem( int id, EntityAI item, string item_name, int category = RadialQuickbarCategory.DEFAULT, int category_switch = -1 )
    {
        m_Id                = id;
        m_Item              = item;
        m_ItemName          = item_name;
        m_Category          = category;
        m_CategorySwitchID  = category_switch;
        
        //
        if (ItemBase.Cast(m_Item))
        {
            m_IsNVG = ItemBase.Cast(m_Item).IsNVG();
            m_IsLightSourceExtra = ItemBase.Cast(m_Item).IsLightSource();
        }
    }
    
    EntityAI GetItem()
    {
        return m_Item;
    }
    
    void SetItem( EntityAI item )
    {
        m_Item = item;
    }
    
    bool IsLightSourceExtra()
    {
        return m_IsLightSourceExtra;
    }
    
    bool IsNVGExtra()
    {
        return m_IsNVG;
    }
    
    int GetId()
    {
        return m_Id;
    }
    
    int GetItemCategory()
    {
        return m_Category;
    }
    
    int GetCategorySwitchID()
    {
        return m_CategorySwitchID;
    }
        
    Widget GetRadialItemCard()
    {
        return m_RadialMenuItemCard;
    }
    
    void SetRadialItemCard( Widget widget )
    {
        m_RadialMenuItemCard = widget;
    }
    
    string GetItemName()
    {
        return m_ItemName;
    }
}
 
class RadialQuickbarMenu extends UIScriptedMenu
{
    protected Widget                                m_ItemCardPanel;
    protected ref array<ref RadialQuickbarItem>     m_Items;
    protected Widget                                m_ToolbarPanel;
    
    protected bool                                  m_IsMenuClosing;
    protected int                                   m_CurrentCategory;
    //
    const string                                    TEXT_ITEM_NAME  = "ItemName";
    const string                                    TEXT_ITEM_TITLE = "ItemTitle";
    //selections
    protected Widget                                m_SelectedItem;
    static EntityAI                                 m_ItemToAssign;
    
    //instance
    static RadialQuickbarMenu                       instance;
    
    //============================================
    // RadialQuickbarMenu
    //============================================
    void RadialQuickbarMenu()
    {
        m_Items = new ref array<ref RadialQuickbarItem>;
        m_CurrentCategory = RadialQuickbarCategory.DEFAULT;
        
        if ( !instance )
        {
            instance = this;
        }
 
        GetGame().GetMission().GetOnInputPresetChanged().Insert(OnInputPresetChanged);
    }
    
    void ~RadialQuickbarMenu()
    {
        if (GetGame() && GetGame().GetMission())
        {
            GetGame().GetMission().RemoveActiveInputExcludes({"radialmenu"},false);
        }
    }
    
    static void SetItemToAssign( EntityAI item )
    {
        m_ItemToAssign = item;
    }
    
    static EntityAI GetItemToAssign()
    {
        return m_ItemToAssign;
    }
    
    static RadialQuickbarMenu GetMenuInstance()
    {
        return instance;
    }
    
    protected void OnInputPresetChanged()
    {
        #ifdef PLATFORM_CONSOLE
        UpdateControlsElements();
        #endif
    }
 
    //============================================
    // Menu Controls
    //============================================  
    static void OpenMenu( UIScriptedMenu parent = NULL )
    {
        GetGame().GetUIManager().EnterScriptedMenu( MENU_RADIAL_QUICKBAR, parent );
    }
    
    static void CloseMenu()
    {
        GetGame().GetUIManager().Back();
        //GetGame().GetMission().RemoveActiveInputExcludes({"radialmenu"},false);
    }
        
    //============================================
    // Init & Widget Events
    //============================================
    override Widget Init()
    {
        layoutRoot = GetGame().GetWorkspace().CreateWidgets("gui/layouts/radial_menu/radial_quickbar/radial_quickbar_menu.layout");
        m_ItemCardPanel = layoutRoot.FindAnyWidget(RadialMenu.RADIAL_ITEM_CARD_CONTAINER);
        
        //register gestures menu
        RadialMenu.GetInstance().RegisterClass(this);
        
        //delay updates until fully initialized
        RadialMenu.GetInstance().SetWidgetInitialized(false);
        
        //set radial menu properties
        RadialMenu.GetInstance().SetWidgetProperties("gui/layouts/radial_menu/radial_quickbar/radial_quickbar_delimiter.layout");
 
        //create content (widgets) for items
        RefreshQuickbar();
        
        //set controller toolbar icons
        UpdateControlsElements();
        
        m_ToolbarPanel = layoutRoot.FindAnyWidget( "toolbar_bg" );
        m_ToolbarPanel.Show( true );
                
        return layoutRoot;
    }
    
    override void OnShow()
    {
        super.OnShow();
        
        Mission mission = GetGame().GetMission();
        if (mission)
        {
            IngameHud hud = IngameHud.Cast(mission.GetHud());
            if (hud)
            {
                hud.ShowQuickbarUI(false);
            }
        }
        
        SetFocus(layoutRoot);
        m_IsMenuClosing = false;
    }
    
    override void OnHide()
    {
        super.OnHide();
        
        Mission mission = GetGame().GetMission();
        if (mission)
        {
            IngameHud hud = IngameHud.Cast(mission.GetHud());
            if (hud)
            {
                hud.ShowQuickbarUI(true);
            }
        }
        
        //reset item to assign
        RadialQuickbarMenu.SetItemToAssign(NULL);
        m_IsMenuClosing = true;
    }
    
    override bool OnController( Widget w, int control, int value )
    {
        super.OnController( w, control, value );
        
        RadialMenu.GetInstance().SetControlType( RadialMenuControlType.CONTROLLER );
 
        return false;
    }   
        
    override bool OnMouseEnter( Widget w, int x, int y )
    {
        super.OnMouseEnter( w, x, y );
        
        RadialMenu.GetInstance().SetControlType( RadialMenuControlType.MOUSE );
 
        return false;
    }   
 
    override bool UseMouse()
    {
        return true;
    }
    
    override bool UseGamepad()
    {
        return true;
    }   
    
    //============================================
    // Content
    //============================================
    //reset_selection - if false, selected quick bar item will be remembered after content refresh
    protected void RefreshQuickbar( bool reset_selection = true )
    {
        int selected_item_id = -1;
        if ( !reset_selection )
        {
            RadialQuickbarItem quickbar_item;
            if ( instance.m_SelectedItem )
            {
                instance.m_SelectedItem.GetUserData( quickbar_item );
                selected_item_id = quickbar_item.GetId();
            }
        }
        
        GetItems( m_Items );
        //CheckForLightsAndNVG( m_Items );
        CreateContent( selected_item_id );
    }   
    
    //
    //  ITEMS
    //
    protected void GetItems( out ref array<ref RadialQuickbarItem> items )
    {
        items.Clear();
        
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        int size = player.GetQuickBarSize();
        EntityAI entity;
        
        for ( int i = 0; i < size; ++i )
        {
            entity = player.GetQuickBarEntity( i );
            
            items.Insert( new RadialQuickbarItem( i, entity, "" ) );
        }
        
        CheckForLightsAndNVG(m_Items,i);
    }
    
    protected void CheckForLightsAndNVG( out ref array<ref RadialQuickbarItem> items, int last_idx )
    {
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        int count = 0;
        EntityAI entity;
        ItemBase headgear = ItemBase.Cast(player.FindAttachmentBySlotName("Headgear"));
        ItemBase eyewear = ItemBase.Cast(player.FindAttachmentBySlotName("Eyewear"));
        
        //nvg - headgear check
        if ( headgear )
        {
            entity = headgear.FindAttachmentBySlotName("NVG");
            if (entity)
            {
                items.Insert( new RadialQuickbarItem( count, entity, "", RadialQuickbarCategory.SPECIALIZED_LIGHTS ) );
                count++;
            }
        }
        //nvg/light - eyewear check
        if ( eyewear )
        {
            entity = eyewear.FindAttachmentBySlotName("NVG");
            if (entity)
            {
                items.Insert( new RadialQuickbarItem( count, entity, "", RadialQuickbarCategory.SPECIALIZED_LIGHTS ) );
                count++;
            }
            else if ( eyewear.IsLightSource() && eyewear.HasEnergyManager() && eyewear.GetCompEM().CanWork() )
            {
                entity = eyewear;
                items.Insert( new RadialQuickbarItem( count, entity, "", RadialQuickbarCategory.SPECIALIZED_LIGHTS ) );
                count++;
            }
        }
        //light
        if ( headgear )
        {
            if ( headgear.GetInventory().AttachmentCount() > 0 )
            {
                ItemBase attachment;
                for (int i = 0; i < headgear.GetInventory().AttachmentCount(); i++)
                {
                    attachment = ItemBase.Cast(headgear.GetInventory().GetAttachmentFromIndex(i));
                    if ( attachment && attachment.IsLightSource() && attachment.HasEnergyManager() && attachment.GetCompEM().CanWork() )
                    {
                        entity = attachment;
                        items.Insert( new RadialQuickbarItem( count, entity, "", RadialQuickbarCategory.SPECIALIZED_LIGHTS ) );
                        count++;
                    }
                }
            }
        }
        
        //Add a category switchers
        if (m_CurrentCategory == RadialQuickbarCategory.DEFAULT && count > 0)
        {
            items.InsertAt( new RadialQuickbarItem(32,null,"#toggle_lights",RadialQuickbarCategory.DEFAULT,RadialQuickbarCategory.SPECIALIZED_LIGHTS),0 );
        }
        else if (m_CurrentCategory == RadialQuickbarCategory.SPECIALIZED_LIGHTS)
        {
            items.InsertAt( new RadialQuickbarItem(32,null,"#menu_back",RadialQuickbarCategory.SPECIALIZED_LIGHTS,RadialQuickbarCategory.DEFAULT),0 );
        }
    }
    
    protected void CreateContent( int selected_item_id = -1 )
    {
        //delete existing content
        DeleteItems();
        
        int category_item_count;
        
        for ( int i = 0; i < m_Items.Count(); ++i )
        {
            RadialQuickbarItem quickbar_item = m_Items.Get( i );
            
            if (quickbar_item.GetItemCategory() == m_CurrentCategory)
            {
                //create item card
                Widget item_card_widget = Widget.Cast( GetGame().GetWorkspace().CreateWidgets( "gui/layouts/radial_menu/radial_quickbar/radial_quickbar_item_card.layout", m_ItemCardPanel ) );
                quickbar_item.SetRadialItemCard( item_card_widget );
                
                //update item card widget
                UpdateQuickbarItemCard( quickbar_item );
                
                //set data
                item_card_widget.SetUserData( quickbar_item );
                
                //set selection
                if ( quickbar_item.GetId() == selected_item_id )
                {
                    MarkSelected( quickbar_item.GetRadialItemCard() );
                }
                category_item_count++;
            }
        }   
 
        //adjust radial parameters for content
        if ( /*m_Items.Count()*/category_item_count > 0 ) 
        {
            RadialMenu radial_menu = RadialMenu.GetInstance();
            radial_menu.SetRadiusOffset( 0 );
            radial_menu.SetExecuteDistOffset( 0.5 );
            radial_menu.SetOffsetFromTop( 0 );
            radial_menu.SetItemCardRadiusOffset( 0.25 );
            radial_menu.ActivateControllerTimeout( false );
        }
        
        //refresh radial menu
        RadialMenu.GetInstance().Refresh( false );
    }
    
    protected void UpdateQuickbarItemCard( RadialQuickbarItem quickbar_item )
    {
        Widget item_card_widget = quickbar_item.GetRadialItemCard();
 
        //get content panels
        Widget item_details = item_card_widget.FindAnyWidget( "ItemDetails" );
        TextWidget item_title = TextWidget.Cast( item_card_widget.FindAnyWidget( "ItemTitle" ) );
        
        //set text
        TextWidget text_widget = TextWidget.Cast( item_card_widget.FindAnyWidget( TEXT_ITEM_NAME ) );
        EntityAI item = quickbar_item.GetItem();
        
        Widget quantity_panel = item_card_widget.FindAnyWidget( "QuantityPanel" );
        if ( item ) 
        {
            //item text
            text_widget.SetText( quickbar_item.GetItem().GetDisplayName() );
            
            //item preview
            ItemPreviewWidget item_preview = ItemPreviewWidget.Cast( item_card_widget.FindAnyWidget( "ItemPreview" ) );
            item_preview.SetItem( item );
            item_preview.SetView( item.GetViewIndex() );
            item_preview.SetModelOrientation( Vector( 0,0,0 ) );
            
            //item quantity
            Widget quantity_stack = quantity_panel.FindAnyWidget( "QuantityStackPanel" );
            ProgressBarWidget quantity_bar = ProgressBarWidget.Cast( quantity_panel.FindAnyWidget( "QuantityBar" ) );
            int has_quantity = QuantityConversions.HasItemQuantity( item );
            //calculate and set quantity
            if ( has_quantity == QUANTITY_HIDDEN )
            {
                quantity_panel.Show( false );
            }
            else if ( has_quantity == QUANTITY_COUNT )
            {
                //hide bar
                quantity_bar.Show( false );
                
                //show stack
                TextWidget quantity_text = TextWidget.Cast( quantity_stack.FindAnyWidget( "Quantity" ) );
                quantity_text.SetText( QuantityConversions.GetItemQuantityText( item ) );
                quantity_stack.Show( true );
            }
            else if ( has_quantity == QUANTITY_PROGRESS )
            {
                //hide stack
                quantity_stack.Show( false );
                
                //show bar
                float progress_max = quantity_bar.GetMax();
                int max = item.ConfigGetInt( "varQuantityMax" );
                int count = item.ConfigGetInt( "count" );
                float quantity = QuantityConversions.GetItemQuantity( ItemBase.Cast( item ) );
                
                if ( count > 0 )
                {
                    max = count;
                }
                if ( max > 0 )
                {
 
                    float value = Math.Round( ( quantity / max ) * 100 );
                    quantity_bar.SetCurrent( value );
                }
                
                quantity_bar.Show( true );
            }
            
            //display content panels
            item_details.Show( true );
            item_title.Show( false );
        }
        else if ( quickbar_item.GetCategorySwitchID() != -1 )
        {
            item_title.SetText( quickbar_item.GetItemName() );
            
            item_details.Show( false );
            item_title.Show( true );    
        }
        else
        {
            item_title.SetText( "#container_empty" );
            
            //display content panels
            item_details.Show( false );
            item_title.Show( true );            
        }           
    }
    
    //Common
    protected void DeleteItems()
    {
        Widget child;
        Widget child_to_destroy;
        
        child = m_ItemCardPanel.GetChildren();
        while ( child )
        {
            child_to_destroy = child;
            child = child.GetSibling();
            
            delete child_to_destroy;
        }       
    }
    
    protected void ChangeCurrentCategory(int category)
    {
        m_CurrentCategory = category;
        RefreshQuickbar(false);
        UpdateControlsElements();
    }
    
    //============================================
    // Radial Menu Events
    //============================================
    //Common
    void OnControlsChanged( RadialMenuControlType type )
    {
    }
    
    //Mouse
    void OnMouseSelect( Widget w )
    {
        MarkSelected( w );
    }
 
    void OnMouseDeselect( Widget w )
    {
        UnmarkSelected( w );
    }
 
    void OnMouseExecute( Widget w )
    {
    }
    
    void OnMousePressLeft( Widget w )
    {
        PrimaryAction( w );
    }
    
    void OnMousePressRight( Widget w )
    {
        BackOneLevel();
    }
    
    //Controller
    void OnControllerSelect( Widget w )
    {
        MarkSelected( w );
    }
 
    void OnControllerDeselect( Widget w )
    {
        UnmarkSelected( w );
    }
 
    void OnControllerPressSelect( Widget w )
    {
        PrimaryAction( w );
    }
    
    void OnControllerPressBack( Widget w )
    {
        //SecondaryAction( w );
        BackOneLevel();
    }
    
    //Actions
    protected void MarkSelected( Widget w )
    {
        m_SelectedItem = w;
        
        if (w)
        {
            RadialQuickbarItem quickbar_item;
            w.GetUserData( quickbar_item );
            ItemBase item;
            
            if (quickbar_item && Class.CastTo(item,quickbar_item.GetItem()))
            {
                w.SetFlags(WidgetFlags.DISABLED);
            }
            else
            {
                w.ClearFlags(WidgetFlags.DISABLED);
            }
/*
            //is not category
            if ( quickbar_item )
            {
                if ( quickbar_item.GetItem() )
                {
                    //alter item visual
                    TextWidget text_widget = TextWidget.Cast( quickbar_item.GetRadialItemCard().FindAnyWidget( TEXT_ITEM_NAME ) );
                    text_widget.SetColor( ARGB( 255, 66, 175, 95 ) );
                }
                else
                {
                    //alter item visual
                    TextWidget title_widget = TextWidget.Cast( quickbar_item.GetRadialItemCard().FindAnyWidget( TEXT_ITEM_TITLE ) );
                    title_widget.SetColor( ARGB( 255, 66, 175, 95 ) );
                }
            }
*/
        }
    }
    
    protected void UnmarkSelected( Widget w )
    {
        m_SelectedItem = NULL;
        
        /*
        if ( w )
        {
            RadialQuickbarItem quickbar_item;
            w.GetUserData( quickbar_item );
 
            //is not category
            if ( quickbar_item )
            {           
                if ( quickbar_item.GetItem() )
                {
                    //alter item visual
                    TextWidget text_widget = TextWidget.Cast( quickbar_item.GetRadialItemCard().FindAnyWidget( TEXT_ITEM_NAME ) );
                    text_widget.SetColor( ARGB( 255, 255, 255, 255 ) );
                }
                else
                {
                    //alter item visual
                    TextWidget title_widget = TextWidget.Cast( quickbar_item.GetRadialItemCard().FindAnyWidget( TEXT_ITEM_TITLE ) );
                    title_widget.SetColor( ARGB( 255, 255, 255, 255 ) );                    
                }
            }
        }
        */
    }
    
    protected void PrimaryAction( Widget w )
    {
        if ( instance.m_SelectedItem )
        {
            if ( !GetGame().IsDedicatedServer() )
            {
                RadialQuickbarItem quickbar_item;
                instance.m_SelectedItem.GetUserData( quickbar_item );
            
                if ( quickbar_item ) 
                {
                    PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
                    
                    //ASSIGN ACTION
                    if ( GetItemToAssign() )
                    {
                        //assign item to slot
                        if ( quickbar_item.GetItem() == GetItemToAssign() )
                        {
                            player.RemoveQuickBarEntityShortcut( GetItemToAssign() );
                        }
                        else
                        {
                            player.SetQuickBarEntityShortcut( GetItemToAssign(), quickbar_item.GetId() );
                        }
                    }
                    //LIGHTS
                    else if (m_CurrentCategory == RadialQuickbarCategory.SPECIALIZED_LIGHTS && quickbar_item.IsLightSourceExtra())
                    {
                        HandleLights(quickbar_item);
                    }
                    //NVG
                    else if (m_CurrentCategory == RadialQuickbarCategory.SPECIALIZED_LIGHTS && quickbar_item.IsNVGExtra())
                    {
                        HandleNVG(quickbar_item);
                    }
                    //change quickbar category
                    else if (quickbar_item.GetCategorySwitchID() != -1)
                    {
                        ChangeCurrentCategory(quickbar_item.GetCategorySwitchID());
                        return;
                    }
                    //SWAP
                    else
                    {
                        EntityAI item = quickbar_item.GetItem();
                        
                        if ( item )
                        {
                            //swap
                            player.RadialQuickBarSingleUse( quickbar_item.GetId() + 1 );                //id must begin with 1 (simulating key press 1-9)
                        }
                    }
                    
                    RefreshQuickbar( false );
                }
            }
        }
    }
    
    protected void SecondaryAction( Widget w )
    {
        if ( instance.m_SelectedItem && m_CurrentCategory == RadialQuickbarCategory.DEFAULT )
        {
            if ( !GetGame().IsDedicatedServer() )
            {
                RadialQuickbarItem quickbar_item;
                instance.m_SelectedItem.GetUserData( quickbar_item );
            
                if ( quickbar_item ) 
                {
                    PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
                    EntityAI item = quickbar_item.GetItem();
                    
                    if ( item )
                    {
                        player.RadialQuickBarCombine( quickbar_item.GetId() + 1 );  //id must begin with 1 (simulating key press 1-9)
                        RefreshQuickbar( false );
                    }   
                }
            }
        }
    }
    
    // returns to default, missing hierarchy to properly traverse ATM
    protected void BackOneLevel()
    {
        if (m_CurrentCategory != RadialQuickbarCategory.DEFAULT)
        {
            ChangeCurrentCategory(RadialQuickbarCategory.DEFAULT);
        }
    }
    
    //-------------------------------------------
    //NVG/Light handling extension
    //-------------------------------------------
    void HandleLights(RadialQuickbarItem quickbar_item)
    {
        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        ItemBase item = ItemBase.Cast(quickbar_item.GetItem());
        ActionManagerClient mngr_client = ActionManagerClient.Cast(player.GetActionManager());
        ActionTarget atrg;
        
        if ( Headtorch_ColorBase.Cast(item) )       
        {
            atrg = new ActionTarget(item,null,-1,vector.Zero,-1.0);
            if ( mngr_client.GetAction(ActionTurnOnHeadtorch).Can(player,atrg,null) )
            {
                mngr_client.PerformActionStart(player.GetActionManager().GetAction(ActionTurnOnHeadtorch),atrg,null);
            }
            else if ( mngr_client.GetAction(ActionTurnOffHeadtorch).Can(player,atrg,null) )
            {
                mngr_client.PerformActionStart(player.GetActionManager().GetAction(ActionTurnOffHeadtorch),atrg,null);
            }
        }
        else if ( Mich2001Helmet.Cast(item.GetHierarchyParent()) )
        {
            atrg = new ActionTarget(item.GetHierarchyParent(),null,-1,vector.Zero,-1.0);
            if ( mngr_client.GetAction(ActionTurnOnHelmetFlashlight).Can(player,atrg,null) )
            {
                mngr_client.PerformActionStart(player.GetActionManager().GetAction(ActionTurnOnHelmetFlashlight),atrg,null);
            }
            else if ( mngr_client.GetAction(ActionTurnOffHelmetFlashlight).Can(player,atrg,null) )
            {
                mngr_client.PerformActionStart(player.GetActionManager().GetAction(ActionTurnOffHelmetFlashlight),atrg,null);
            }
        }
    }
    
    void HandleNVG(RadialQuickbarItem quickbar_item)
    {
        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        ActionManagerClient mngr_client = ActionManagerClient.Cast(player.GetActionManager());
        ActionTarget atrg;
        
        atrg = new ActionTarget(quickbar_item.GetItem().GetHierarchyParent(),null,-1,vector.Zero,-1.0);
        if ( mngr_client.GetAction(ActionToggleNVG).Can(player,atrg,null) )
        {
            mngr_client.PerformActionStart(player.GetActionManager().GetAction(ActionToggleNVG),atrg,null);
        }
    }
    
    bool IsMenuClosing()
    {
        return m_IsMenuClosing;
    }
    
    void SetMenuClosing(bool state)
    {
        m_IsMenuClosing = state;
    }
 
    protected void UpdateControlsElements()
    {
        Widget toolbarBackSpacer = layoutRoot.FindAnyWidget("BackSpacer");
 
        RichTextWidget toolbarSelectIcon = RichTextWidget.Cast(layoutRoot.FindAnyWidget("SelectIcon"));
        RichTextWidget toolbarBackIcon = RichTextWidget.Cast(layoutRoot.FindAnyWidget("BackIcon"));
        
        string selectAction;
        string backAction;
        int controllerID;
        
        if (GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer() && GetGame().GetInput().GetCurrentInputDevice() == EInputDeviceType.MOUSE_AND_KEYBOARD)
        {
            selectAction = "UAMenuSelect";
            backAction = "UAMenuBack";
            controllerID = EUAINPUT_DEVICE_KEYBOARDMOUSE;
        }
        else
        {
            selectAction = "UAUISelect";
            backAction = "UAUIBack";
            controllerID = EUAINPUT_DEVICE_CONTROLLER;
        }
        
        toolbarSelectIcon.SetText(InputUtils.GetRichtextButtonIconFromInputAction(selectAction, "", controllerID, InputUtils.ICON_SCALE_TOOLBAR));
        toolbarBackIcon.SetText(InputUtils.GetRichtextButtonIconFromInputAction(backAction, "", controllerID, InputUtils.ICON_SCALE_TOOLBAR));
        toolbarBackSpacer.Show(m_CurrentCategory != RadialQuickbarCategory.DEFAULT);
    }
}