TabberUI.c

Go to the documentation of this file.

class TabberUI extends ScriptedWidgetEventHandler
{
  protected bool m_FirstInit = true;
  protected Widget m_Root;
  protected Widget m_TabControlsRoot;
 
  protected int m_TabsCount;
  protected ref map<int, Widget> m_TabControls;
  protected ref map<int, Widget> m_Tabs;
 
  protected int m_SelectedIndex;
  protected float m_ResolutionMultiplier;
  protected bool m_CanSwitch;
 
  ref ScriptInvoker m_OnTabSwitch = new ScriptInvoker();
  ref ScriptInvoker m_OnAttemptTabSwitch = new ScriptInvoker();
  ref Timer m_InitTimer;
 
  protected void OnInputPresetChanged()
  {
#ifdef PLATFORM_CONSOLE
    UpdateControlsElements();
#endif
  }
 
  protected void OnInputDeviceChanged(EInputDeviceType pInputDeviceType)
  {
    switch (pInputDeviceType)
    {
    case EInputDeviceType.CONTROLLER:
      UpdateControlsElements();
      m_TabControlsRoot.FindAnyWidget("ConsoleControls").Show(true);
      break;
 
    default:
      if (GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer())
        m_TabControlsRoot.FindAnyWidget("ConsoleControls").Show(false);
      break;
    }
  }
 
  void Init()
  {
    int x, y;
    GetScreenSize(x, y);
    m_ResolutionMultiplier = y / 1080;
    m_CanSwitch = true;
    m_TabsCount = 0;
 
    Widget tab_controls = m_Root.FindAnyWidget("Tab_Control_Container");
    if (tab_controls)
    {
      Widget tab_child = tab_controls.GetChildren();
 
      while (tab_child)
      {
        m_TabsCount++;
        tab_child = tab_child.GetSibling();
      }
 
      for (int i = 0; i < m_TabsCount; i++)
      {
        Widget tab_control = tab_controls.FindAnyWidget("Tab_Control_" + i);
        Widget tab_widget = m_Root.FindAnyWidget("Tab_" + i);
        if (tab_control && tab_widget)
        {
          tab_control.SetHandler(this);
          m_TabControls.Insert(i, tab_control);
          m_Tabs.Insert(i, tab_widget);
        }
        else
          Error("Tabber could not find correctly named tab or control at index " + i);
      }
 
      AlignTabbers();
#ifdef PLATFORM_CONSOLE
      UpdateControlsElements();
#endif
 
      SelectTabControl(0);
 
      m_InitTimer.Run(0.01, this, "AlignTabbers");
    }
 
    GetGame().GetMission().GetOnInputPresetChanged().Insert(OnInputPresetChanged);
    GetGame().GetMission().GetOnInputDeviceChanged().Insert(OnInputDeviceChanged);
 
    OnInputDeviceChanged(GetGame().GetInput().GetCurrentInputDevice());
  }
 
  void OnWidgetScriptInit(Widget w)
  {
    m_TabsCount = 0;
    m_TabControls = new map<int, Widget>;
    m_Tabs = new map<int, Widget>;
 
    m_Root = w;
    m_InitTimer = new Timer();
    m_TabControlsRoot = m_Root.FindAnyWidget("TabControls");
 
    Init();
  }
 
  void AlignTabbers()
  {
    float total_size;
    float x, y;
 
    Widget tab_controls_container = m_TabControlsRoot.FindAnyWidget("Tab_Control_Container");
    Widget tab_controls_scroller = m_TabControlsRoot.FindAnyWidget("Tab_Control_Scroller");
 
    m_TabControlsRoot.Update();
    tab_controls_container.Update();
 
    Widget tab_child = tab_controls_container.GetChildren();
    while (tab_child)
    {
      if (tab_child.IsVisible())
      {
        TextWidget tab_text = TextWidget.Cast(tab_child.FindAnyWidget(tab_child.GetName() + "_Title"));
        int t_x, t_y;
        tab_text.Update();
        tab_text.GetTextSize(t_x, t_y);
        tab_child.SetSize(t_x + 10 * m_ResolutionMultiplier, 1);
        tab_controls_container.Update();
 
        total_size += (t_x + 10 * m_ResolutionMultiplier);
      }
 
      tab_child = tab_child.GetSibling();
    }
 
    tab_child = tab_controls_container.GetChildren();
 
    float x_f_c, y_f_c;
    tab_controls_container.GetScreenPos(x_f_c, y_f_c);
 
    while (tab_child)
    {
      Widget tab_bg = tab_child.FindAnyWidget(tab_child.GetName() + "_Background");
      tab_child.GetScreenPos(x, y);
      tab_bg.SetPos((x_f_c - x), 0);
      tab_bg.SetSize(total_size, 1);
 
      tab_child = tab_child.GetSibling();
    }
 
    m_TabControlsRoot.GetSize(x, y);
 
    m_TabControlsRoot.SetSize(total_size, y);
    tab_controls_container.Update();
    if (tab_controls_scroller)
      tab_controls_scroller.Update();
    m_TabControlsRoot.Update();
  }
 
  int AddTab(string name)
  {
    int new_index = m_Tabs.Count();
    Widget tab = GetGame().GetWorkspace().CreateWidgets("gui/layouts/new_ui/tabber_prefab/tab.layout", m_Root);
    Widget control = GetGame().GetWorkspace().CreateWidgets("gui/layouts/new_ui/tabber_prefab/tab_control.layout", m_Root.FindAnyWidget("Tab_Control_Container"));
    TextWidget control_text = TextWidget.Cast(control.FindAnyWidget("Tab_Control_x_Title"));
 
    tab.SetName("Tab_" + new_index);
    control.SetName("Tab_Control_" + new_index);
    control_text.SetName("Tab_Control_" + new_index + "_Title");
    control.FindAnyWidget("Tab_Control_x_Background").SetName("Tab_Control_" + new_index + "_Background");
 
    control_text.SetText(name);
 
    control.SetHandler(this);
    m_TabControls.Insert(new_index, control);
    m_Tabs.Insert(new_index, tab);
 
    AlignTabbers();
 
    return new_index;
  }
 
  void RemoveTab(int index)
  {
 
  }
 
 
  Widget GetTab(int index)
  {
    return m_Tabs.Get(index);
  }
 
  int GetTabCount()
  {
    return m_Tabs.Count();
  }
 
  bool CanSwitchTab()
  {
    return m_CanSwitch;
  }
 
  void SetCanSwitch(bool value)
  {
    m_CanSwitch = value;
  }
 
  void PerformSwitchTab(int index)
  {
    DeselectTabControl(m_SelectedIndex);
    DeselectTabPanel(m_SelectedIndex);
 
    SelectTabControl(index);
    SelectTabPanel(index);
 
    m_SelectedIndex = index;
    m_OnTabSwitch.Invoke(m_SelectedIndex);
 
    if (m_FirstInit)
    {
      AlignTabbers();
      m_FirstInit = false;
    }
  }
 
  override bool OnMouseEnter(Widget w, int x, int y)
  {
    int index = m_TabControls.GetKeyByValue(w);
    if (m_SelectedIndex == index)
      return false;
 
    Widget tab_control = m_TabControls.Get(index);
    if (tab_control)
    {
      Widget tab_title = TextWidget.Cast(tab_control.FindAnyWidget(tab_control.GetName() + "_Title"));
      tab_title.SetColor(ARGB(255, 255, 0, 0));
      tab_control.SetColor(ARGB(255, 0, 0, 0));
    }
 
    return false;
  }
 
  override bool OnMouseLeave(Widget w, Widget enterW, int x, int y)
  {
    int index = m_TabControls.GetKeyByValue(w);
    if (m_SelectedIndex == index)
      return false;
 
    Widget tab_control = m_TabControls.Get(index);
    if (tab_control)
    {
      Widget tab_title = TextWidget.Cast(tab_control.FindAnyWidget(tab_control.GetName() + "_Title"));
      tab_title.SetColor(ARGB(255, 255, 255, 255));
      tab_control.SetColor(ARGB(0, 0, 0, 0));
    }
    return false;
  }
 
  override bool OnMouseButtonUp(Widget w, int x, int y, int button)
  {
    if (button == MouseState.LEFT)
    {
      int index = m_TabControls.GetKeyByValue(w);
      if (m_SelectedIndex != index)
      {
        m_OnAttemptTabSwitch.Invoke(m_SelectedIndex, index);
        if (CanSwitchTab())
        {
          PerformSwitchTab(index);
 
          return true;
        }
      }
    }
 
    return false;
  }
 
  override bool OnChildAdd(Widget w, Widget child)
  {
    if (w == m_Root.FindAnyWidget("Tab_Control_Container"))
    {
      AlignTabbers();
      return true;
    }
    return false;
  }
 
  override bool OnChildRemove(Widget w, Widget child)
  {
    if (w == m_Root.FindAnyWidget("Tab_Control_Container"))
    {
      AlignTabbers();
      return true;
    }
    return false;
  }
 
  void EnableTabControl(int index, bool enable)
  {
    Widget tab_control = m_Root.FindAnyWidget("Tab_Control_" + index);
    if (tab_control)
      tab_control.Show(enable);
    AlignTabbers();
  }
 
  void SelectTabControl(int index)
  {
    Widget tab_control = m_TabControls.Get(index);
    if (tab_control)
    {
      /*
        Widget tab_bg = tab_control.FindAnyWidget( tab_control.GetName() + "_Background" );
        if( tab_bg )
        {
        tab_bg.Show( true );
        }
      */
 
      Widget tab_title = TextWidget.Cast(tab_control.FindAnyWidget(tab_control.GetName() + "_Title"));
 
      int color_title = ARGB(255, 255, 0, 0);
      int color_backg = ARGB(255, 0, 0, 0);
 
#ifdef PLATFORM_CONSOLE
      color_title = ARGB(255, 255, 255, 255);
      color_backg = ARGB(255, 200, 0, 0);
#endif
 
      tab_title.SetColor(color_title);
      tab_control.SetColor(color_backg);
    }
  }
 
  void SelectTabPanel(int index)
  {
    Widget tab = m_Tabs.Get(index);
    if (tab)
      tab.Show(true);
  }
 
  void DeselectTabControl(int index)
  {
    Widget tab_control = m_TabControls.Get(index);
    if (tab_control)
    {
      /*
        Widget tab_bg = tab_control.FindAnyWidget( tab_control.GetName() + "_Background" );
        if( tab_bg )
        {
        tab_bg.Show( false );
        }
      */
      Widget tab_title = TextWidget.Cast(tab_control.FindAnyWidget(tab_control.GetName() + "_Title"));
      tab_title.SetColor(ARGB(255, 255, 255, 255));
      tab_control.SetColor(ARGB(0, 0, 0, 0));
    }
  }
 
  void DeselectTabPanel(int index)
  {
    Widget tab = m_Tabs.Get(index);
    if (tab)
      tab.Show(false);
  }
 
  void DeselectAll()
  {
    for (int i = 0; i < m_TabControls.Count(); i++)
    {
      DeselectTabControl(i);
      DeselectTabPanel(i);
    }
  }
 
  void NextTab()
  {
    int next_index = m_SelectedIndex + 1;
 
    while (next_index < m_Tabs.Count() && !m_TabControls[next_index].IsVisible())
      next_index++;
 
    if (next_index >= m_Tabs.Count())
      next_index = 0;
 
    if (m_SelectedIndex != next_index)
    {
      m_OnAttemptTabSwitch.Invoke(m_SelectedIndex, next_index);
      if (CanSwitchTab())
        PerformSwitchTab(next_index);
    }
 
    if (m_FirstInit)
    {
      AlignTabbers();
      m_FirstInit = false;
    }
  }
 
  void PreviousTab()
  {
    int next_index = m_SelectedIndex - 1;
 
    if (next_index < 0)
      next_index = m_TabControls.Count() - 1;
 
    while (next_index > 0 && !m_TabControls[next_index].IsVisible())
      next_index--;
 
    if (m_SelectedIndex != next_index)
    {
      m_OnAttemptTabSwitch.Invoke(m_SelectedIndex, next_index);
      if (CanSwitchTab())
        PerformSwitchTab(next_index);
    }
 
    if (m_FirstInit)
    {
      AlignTabbers();
      m_FirstInit = false;
    }
  }
 
  int GetSelectedIndex()
  {
    return m_SelectedIndex;
  }
 
  void RefreshTab(bool performInitAlignment = false)
  {
    m_FirstInit = performInitAlignment;
    DeselectAll();
    PerformSwitchTab(m_SelectedIndex);
  }
 
  protected void UpdateControlsElements()
  {
    Widget xbControls = m_Root.FindAnyWidget("ConsoleControls");
    if (xbControls)
    {
      xbControls.Show(m_TabsCount > 1);
 
      RichTextWidget toolbar_lb = RichTextWidget.Cast(xbControls.FindAnyWidget("TabLeftControl"));
      RichTextWidget toolbar_rb = RichTextWidget.Cast(xbControls.FindAnyWidget("TabRightControl"));
      if (toolbar_lb)
        toolbar_lb.SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUITabLeft", "", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 
      if (toolbar_rb)
        toolbar_rb.SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUITabRight", "", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
    }
  }
 
  void DisableTabs(bool disable)
  {
    foreach (Widget w : m_Tabs)
    {
      if (disable)
        w.SetFlags(WidgetFlags.IGNOREPOINTER);
      else
        w.ClearFlags(WidgetFlags.IGNOREPOINTER);
      w.Enable(!disable);
    }
  }
}