ScriptConsoleConfigTab.c

Go to the documentation of this file.

typedef Param5<bool, string, int, string, int> ConfigParams; // param1 - isCollapsed, param2 - string name, param3 - num of childs, param4 - path, param5 - deep
typedef Param6<bool, string, int, string, int, string> ConfigParamsEx; // param1 - isCollapsed, param2 - string name, param3 - num of childs, param4 - path, param5 - deep
 
class ScriptConsoleConfigTab : ScriptConsoleTabBase
{
 
  protected static string m_ConfigTextField;
  protected static string m_VariableTextField;
  protected static ref ConfigParamsEx m_ConfigData;
  protected ref TStringArray m_BaseConfigClasses = new TStringArray;
  protected ref TStringArray m_BaseConfigClassesToggled = new TStringArray;
  protected ref map<CheckBoxWidget, int> m_ClassCheckboxes = new map<CheckBoxWidget, int>;
 
  protected EditBoxWidget m_ObjectConfigFilter;
  protected EditBoxWidget m_VariableConfigFilter;
  protected TextListboxWidget m_ConfigHierarchyTextListbox;
  protected TextListboxWidget m_ConfigVariablesTextListbox;
  protected ButtonWidget m_SelectedRowCopy;
  protected ButtonWidget m_DumpParamButton;
  protected TextWidget m_ClassPath;
 
 
  protected Widget m_WgtClassesConfig;
  protected PluginConfigViewer m_ModuleConfigViewer;
  protected int m_Row;
 
  void ScriptConsoleConfigTab(Widget root, ScriptConsole console, Widget button, ScriptConsoleTabBase parent = null)
  {
    m_WgtClassesConfig = root.FindAnyWidget("ClassesPanel");
    m_DumpParamButton = ButtonWidget.Cast(root.FindAnyWidget("DumpParamButton"));
    m_ObjectConfigFilter = EditBoxWidget.Cast(root.FindAnyWidget("ObjectConfigFilter"));
    m_VariableConfigFilter = EditBoxWidget.Cast(root.FindAnyWidget("VariableConfigFilter"));
    m_ConfigHierarchyTextListbox = TextListboxWidget.Cast(root.FindAnyWidget("ConfigHierarchy"));
    m_ConfigVariablesTextListbox = TextListboxWidget.Cast(root.FindAnyWidget("ConfigVariables"));
    m_SelectedRowCopy = ButtonWidget.Cast(root.FindAnyWidget("SelectedRowCopy"));
    m_ClassPath = TextWidget.Cast(root.FindAnyWidget("ClassPath"));
 
    if (m_ConfigTextField)
      m_ObjectConfigFilter.SetText(m_ConfigTextField);
    if (m_VariableTextField)
      m_VariableConfigFilter.SetText(m_VariableTextField);
    Init();
  }
 
  void ~ScriptConsoleConfigTab()
  {
    m_VariableTextField = m_VariableConfigFilter.GetText();
 
    foreach (int i: m_ClassCheckboxes)
    {
      Widget w = m_ClassCheckboxes.GetKeyByValue(i);
      w.GetParent().Unlink();
    }
  }
 
  override bool OnChange(Widget w, int x, int y, bool finished)
  {
    super.OnChange(w, x, y, finished);
    if (w == m_ObjectConfigFilter)
    {
      ChangeConfigFilter();
      return true;
    }
    else if (w == m_VariableConfigFilter)
    {
      RenderVariables(m_Row);
      return true;
    }
 
    return false;
  }
 
  override bool OnItemSelected(Widget w, int x, int y, int row, int column, int oldRow, int oldColumn)
  {
    super.OnItemSelected(w, x, y, row, column, oldRow, oldColumn);
 
    if (w == m_ConfigHierarchyTextListbox)
    {
      TextListboxWidget wgt = TextListboxWidget.Cast(w);
      wgt.GetItemData(row, 0, m_ConfigData);
      RenderClassPath();
 
      return true;
    }
    return false;
  }
 
  void RenderClassPath()
  {
    m_ClassPath.SetText(m_ModuleConfigViewer.GetBaseClasses(m_ConfigData.param4, m_ConfigData.param2));
  }
 
 
  override bool OnClick(Widget w, int x, int y, int button)
  {
    super.OnClick(w, x, y, button);
 
    CheckBoxWidget cbw = CheckBoxWidget.Cast(w);
 
    if (w == m_DumpParamButton)
    {
      int selectedRowIndex = m_ConfigVariablesTextListbox.GetSelectedRow();
      string paramFinal;
      if (selectedRowIndex > -1)
      {
        string param;
        m_ConfigVariablesTextListbox.GetItemText(selectedRowIndex, 0, param);
        int index = param.IndexOf("=");
        if (index > 0)
          paramFinal = param.Substring(0, index).Trim();
      }
 
      int objects_row_index;
      objects_row_index = m_ConfigHierarchyTextListbox.GetSelectedRow();
      if (objects_row_index > -1 && objects_row_index < m_ConfigHierarchyTextListbox.GetNumItems())
      {
        ConfigParamsEx params;
        m_ConfigHierarchyTextListbox.GetItemData(objects_row_index, 0, params);
        string path = params.param4;
        TStringArray pathArr = new TStringArray();
        path.Split(" ", pathArr);
        string relativePath;
 
        foreach (int indx, string s: pathArr)
        {
          if (indx > 2)
            relativePath += s + " ";
        }
 
        if (relativePath)
          relativePath = relativePath.Trim();
 
        Print(relativePath);
        Print(path);
      }
 
      if (paramFinal)
        DumpParam(paramFinal, relativePath);
 
      return true;
    }
    else if (w == m_ConfigHierarchyTextListbox)
    {
      objects_row_index = m_ConfigHierarchyTextListbox.GetSelectedRow();
      //Print(objects_row_index);
 
      if (objects_row_index > -1 && objects_row_index < m_ConfigHierarchyTextListbox.GetNumItems())
      {
        ConfigParamsEx config_params;
        m_ConfigHierarchyTextListbox.GetItemData(objects_row_index, 0, config_params);
 
        if (config_params.param1 == false)
          ExpandHierarchy(objects_row_index);
        else
          CollapseHierarchy(objects_row_index);
 
        RenderVariables(objects_row_index);
        m_Row = objects_row_index;
      }
      return true;
    }
    else if (cbw && m_ClassCheckboxes.Contains(cbw))
    {
      int checkbox_index = m_ClassCheckboxes.Get(cbw);
      string base_class_name = m_BaseConfigClasses.Get(checkbox_index);
 
      int index_toggled = m_BaseConfigClassesToggled.Find(base_class_name);
 
      int flag, new_flag;
 
      if (m_ConfigDebugProfile)
        flag = m_ConfigDebugProfile.GetConfigClassesFlag();
 
      if (cbw.IsChecked())
      {
        if (index_toggled == -1)//not found
        {
          m_BaseConfigClassesToggled.Insert(base_class_name);
 
          if (m_ConfigDebugProfile)
            new_flag = (flag | (int)Math.Pow(2, checkbox_index));
        }
      }
      else if (index_toggled != -1)
      {
        m_BaseConfigClassesToggled.Remove(index_toggled);
 
        if (m_ConfigDebugProfile)
          new_flag = (flag ^ (int)Math.Pow(2, checkbox_index));
      }
      m_ConfigDebugProfile.SetConfigClassesFlag(new_flag);
      /*
        Print("-----------------------------------------");
        Print("flag = " + new_flag);
        foreach (string text:m_BaseConfigClassesToggled)
        {
        Print(text);
        }
        Print("-----------------------------------------");
      */
      ClearHierarchy();
    }
    else if (w == m_SelectedRowCopy)
    {
      AddItemToClipboard(m_ConfigVariablesTextListbox);
      return true;
    }
    return false;
  }
 
  override void Update(float timeslice)
  {
    super.Update(timeslice);
 
  }
 
  protected void Init()
  {
    Debug.GetBaseConfigClasses(m_BaseConfigClasses);
    m_ModuleConfigViewer = PluginConfigViewer.Cast(GetPlugin(PluginConfigViewer));
    int flag1;
 
    if (m_ConfigDebugProfile)
      flag1 = m_ConfigDebugProfile.GetConfigClassesFlag();
    //Print("------------------------------------------------");
    foreach (string s: m_BaseConfigClasses)
    {
      Widget w = GetGame().GetWorkspace().CreateWidgets("gui/layouts/script_console/config_class_item.layout", m_WgtClassesConfig);
      CheckBoxWidget cbw = CheckBoxWidget.Cast(w.FindAnyWidget("Item"));
      //cbw.SetColor(Colors.RED);
      cbw.SetText(s);
      int indx = m_ClassCheckboxes.Count();
      m_ClassCheckboxes.Insert(cbw, indx);
      //Print("adding "+cbw +" at index:" + indx);
 
      if (flag1 & (int)Math.Pow(2, indx))
      {
        string base_class_name = m_BaseConfigClasses.Get(indx);
        m_BaseConfigClassesToggled.Insert(base_class_name);
        cbw.SetChecked(true);
      }
    }
 
    ClearHierarchy();
    ChangeConfigFilter();
  }
 
  protected void DumpParam(string param, string relativePath)
  {
    if (relativePath)
      relativePath = " " + relativePath;
    for (int i = 0; i < m_BaseConfigClassesToggled.Count(); i++)
    {
      string config_path = m_BaseConfigClassesToggled.Get(i);
 
      int objects_count = GetGame().ConfigGetChildrenCount(config_path);
 
      for (int j = 0; j < objects_count; j++)
      {
        string child_name;
        GetGame().ConfigGetChildName(config_path, j, child_name);
 
 
        //string dispName;
        //GetGame().ConfigGetText( config_path + " " + child_name + " displayName",dispName );
        string value;
        string path = config_path + " " + child_name + relativePath + " " + param;
        if (GetGame().ConfigIsExisting(path))
        {
          GetGame().ConfigGetText(path, value);
          if (value)
            Print(child_name + "," + param + "," + value);
        }
 
 
        /*
          int scope = GetGame().ConfigGetInt( config_path + " " + child_name + " scope" );
          {
          if ( scope == 2)
          {
 
          }
          }*/
      }
    }
  }
 
  protected void ChangeConfigFilter()
  {
    m_ConfigTextField = m_ObjectConfigFilter.GetText();
 
    if (m_ConfigTextField == "")
      ClearHierarchy();
    else
      FindInHierarchy(m_ConfigTextField);
  }
 
  protected void ClearHierarchy()
  {
    m_ConfigHierarchyTextListbox.ClearItems();
    m_ConfigVariablesTextListbox.ClearItems();
 
    string config_path = "configfile";
    TStringArray variables = m_ModuleConfigViewer.GetConfigHierarchy(config_path);
    for (int i = 0; i < variables.Count(); i++)
    {
      string variable = variables.Get(i);
 
      for (int j = 0; j < m_BaseConfigClassesToggled.Count(); j++)
      {
        if (variable == m_BaseConfigClassesToggled.Get(j))
        {
          string new_config_path = (config_path + " " + variable).Trim();
          m_ConfigHierarchyTextListbox.AddItem("+ " + variable, new ConfigParamsEx(false, variable, 0, new_config_path, 0, variable), 0);
        }
      }
    }
  }
 
  protected void FindInHierarchy(string class_name)
  {
    m_ConfigHierarchyTextListbox.ClearItems();
    m_ConfigVariablesTextListbox.ClearItems();
 
    class_name.ToLower();
    string config_base_path = "configfile";
 
    string filter_lower = class_name;
    filter_lower.ToLower();
 
    TStringArray filters = new TStringArray;
    filter_lower.Split(" ", filters);
 
    for (int i = 0; i < m_BaseConfigClassesToggled.Count(); i++)
    {
      string config_root = m_BaseConfigClassesToggled.Get(i);
      string config_path = config_base_path + " " + config_root;
      TStringArray variables = m_ModuleConfigViewer.GetConfigHierarchy(config_path);
 
      for (int j = 0; j < variables.Count(); j++)
      {
        string variable = variables.Get(j);
        string variable_lower = variable;
        variable_lower.ToLower();
 
        for (int k = 0; k < filters.Count(); k++)
        {
          if (variable_lower.Contains(filters.Get(k)))
          {
            string new_config_path = (config_path + " " + variable).Trim();
            m_ConfigHierarchyTextListbox.AddItem("+ " + variable, new ConfigParamsEx(false, variable, 0, new_config_path, 0, config_root), 0);
            break;
          }
        }
      }
    }
  }
 
  protected void ExpandHierarchy(int row)
  {
    if (row <= -1 && row >= m_ConfigHierarchyTextListbox.GetNumItems())
      return;
 
    TStringArray variables;
 
    // get current row data
    ConfigParamsEx config_params;
    m_ConfigHierarchyTextListbox.GetItemData(row, 0, config_params);
 
    string config_path = config_params.param4;
    int deep = config_params.param5;
 
 
    string offset = "";
    for (int i = 0; i < deep; i++)
      offset = offset + "  ";
 
    // change selected node
    variables = m_ModuleConfigViewer.GetConfigHierarchy(config_path);
    int childrens_count = variables.Count();
    m_ConfigHierarchyTextListbox.SetItem(row, offset + "- " + config_params.param2, new ConfigParamsEx(true, config_params.param2, childrens_count, config_path, deep, config_params.param6), 0);
 
    offset = offset + "  ";
 
    // render children
    deep = deep + 1;
    childrens_count = 0;
    for (i = variables.Count() - 1; i >= 0; i--)
    {
      string new_config_path = (config_path + " " + variables.Get(i)).Trim();
      m_ConfigHierarchyTextListbox.AddItem(offset + "+ " + variables.Get(i), new ConfigParamsEx(false, variables.Get(i), childrens_count, new_config_path, deep, config_params.param2), 0, (row + 1));
    }
  }
 
  // niekde je bug, ked su len 2 polozky a expand/collapse na prvu tak zmaze aj druhu. ak collapse a expand na druhu tak crash lebo sa snazi zmazat riadok co neexistuje
  protected void CollapseHierarchy(int row)
  {
    if (row <= -1 && row >= m_ConfigHierarchyTextListbox.GetNumItems())
      return;
 
    ConfigParamsEx config_params;
    ConfigParamsEx config_params_next;
    m_ConfigHierarchyTextListbox.GetItemData(row, 0, config_params);
    m_ConfigHierarchyTextListbox.GetItemData(row + 1, 0, config_params_next);
 
    if (!config_params || !config_params_next)
      return;
    int deep = config_params.param5;
    int deep_next = config_params_next.param5;
    int max_count = m_ConfigHierarchyTextListbox.GetNumItems();
    int remove_lines_count = 0;
    // Print(max_count);
    for (int i = row + 1; i < max_count; i++)
    {
      if (deep < deep_next && i <= max_count)
      {
        remove_lines_count = remove_lines_count + 1;
        m_ConfigHierarchyTextListbox.GetItemData(i, 0, config_params_next);
        deep_next = config_params_next.param5;
      }
    }
 
    // remove remove_lines_count lines from row
    // remove_lines_count = remove_lines_count - 1;
    for (i = 1; i < remove_lines_count; i++)
    {
      int x = row + 1;
      if (x < max_count)
        m_ConfigHierarchyTextListbox.RemoveRow(x);
    }
 
    string offset = "";
    for (i = 0; i < deep; i++)
      offset = offset + "  ";
    m_ConfigHierarchyTextListbox.SetItem(row, offset + "+ " + config_params.param2, new ConfigParamsEx(false, config_params.param2, 0, config_params.param4, deep, ""), 0);
    /* //not sure why this is here, but it's causing issues when collapsing items in config viewer, disabling for now
      if (deep == 0)
      {
      ClearHierarchy();
      }
    */
  }
 
  protected void RenderVariables(int row)
  {
    if (row > -1 && row < m_ConfigHierarchyTextListbox.GetNumItems())
    {
      string filter_lower = m_VariableConfigFilter.GetText();
      filter_lower.ToLower();
 
      TStringArray filters = new TStringArray();
      filter_lower.Split(" ", filters);
 
      ConfigParamsEx config_params;
 
      m_ConfigHierarchyTextListbox.GetItemData(row, 0, config_params);
      m_ConfigVariablesTextListbox.ClearItems();
      TStringArray variables;
      string path = config_params.param4;
      variables = m_ModuleConfigViewer.GetConfigVariables(path);
 
      for (int i = 0; i < variables.Count(); i++)
      {
        string var = variables.Get(i);
 
        if (filters.Count() == 0)
          m_ConfigVariablesTextListbox.AddItem(var, NULL, 0);
        else
        {
          foreach (string f: filters)
          {
            var.ToLower();
            if (var.Contains(f))
              m_ConfigVariablesTextListbox.AddItem(var, NULL, 0);
          }
        }
      }
    }
  }
 
}