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);
 }
}