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