protected void PropertyField(SerializedProperty property)
{
Assert.IsNotNull(property);
var title = ChartEditorHelper.GetContent(property.displayName);
PropertyField(property, title);
}
protected void PropertyTwoFiled(string relativePropName)
{
var m_DrawRect = GUILayoutUtility.GetRect(1f, 17f);
var prop = FindProperty(relativePropName);
ChartEditorHelper.MakeTwoField(ref m_DrawRect, m_DrawRect.width, prop, prop.displayName);
}
protected void PropertyField(SerializedProperty prop, SerializedProperty relativeProp)
{
if (!ChartEditorHelper.PropertyField(ref m_DrawRect, m_Heights, m_KeyName, relativeProp))
{
Debug.LogError("PropertyField ERROR:" + prop.displayName + ", " + relativeProp);
}
}
public void OnGUI()
{
if (chart == null)
{
return;
}
for (int i = 0; i < m_Editors.Count; i++)
{
var editor = m_Editors[i];
string title = editor.GetDisplayTitle();
int id = i;
bool displayContent = ChartEditorHelper.DrawHeader(
title,
editor.baseProperty,
editor.showProperty,
() => { ResetComponentEditor(id); },
() => { RemoveComponentEditor(id); }
);
if (displayContent)
{
editor.OnInternalInspectorGUI();
}
}
if (m_Editors.Count == 0)
{
EditorGUILayout.HelpBox("No componnet.", MessageType.Info);
}
}
private void AddComponent()
{
if (GUILayout.Button(Styles.btnAddComponent))
{
var menu = new GenericMenu();
foreach (var type in GetMainComponentTypeNames())
{
var title = ChartEditorHelper.GetContent(type.Name);
bool exists = !m_Chart.CanAddChartComponent(type);
if (!exists)
{
menu.AddItem(title, false, () =>
{
m_ComponentList.AddChartComponent(type);
});
}
else
{
menu.AddDisabledItem(title);
}
}
menu.ShowAsContext();
}
}
private void DrawSerieDataDetail(SerializedProperty m_Datas, int index)
{
EditorGUI.indentLevel++;
var serieData = m_Datas.GetArrayElementAtIndex(index);
var m_Name = serieData.FindPropertyRelative("m_Name");
PropertyField(m_Name);
if (serie.GetType().IsDefined(typeof(SerieDataExtraFieldAttribute), false))
{
var attribute = serie.GetType().GetAttribute <SerieDataExtraFieldAttribute>();
foreach (var field in attribute.fields)
{
PropertyField(serieData.FindPropertyRelative(field));
}
}
serieDataMenus.Clear();
if (serie.GetType().IsDefined(typeof(SerieDataExtraComponentAttribute), false))
{
var attribute = serie.GetType().GetAttribute <SerieDataExtraComponentAttribute>();
foreach (var type in attribute.types)
{
var size = serieData.FindPropertyRelative(SerieData.extraComponentMap[type]).arraySize;
serieDataMenus.Add(new HeaderMenuInfo("Add " + type.Name, () =>
{
serie.GetSerieData(index).GetOrAddComponent(type);
EditorUtility.SetDirty(chart);
}, size == 0));
}
foreach (var type in attribute.types)
{
var size = serieData.FindPropertyRelative(SerieData.extraComponentMap[type]).arraySize;
serieDataMenus.Add(new HeaderMenuInfo("Remove " + type.Name, () =>
{
serie.GetSerieData(index).RemoveComponent(type);
EditorUtility.SetDirty(chart);
}, size > 0));
}
}
serieDataMenus.Add(new HeaderMenuInfo("Remove All", () =>
{
serie.GetSerieData(index).RemoveAllComponent();
}, true));
m_DataComponentFoldout = ChartEditorHelper.DrawHeader("Component", m_DataComponentFoldout, false, null, null, serieDataMenus);
if (m_DataComponentFoldout)
{
foreach (var kv in SerieData.extraComponentMap)
{
var prop = serieData.FindPropertyRelative(kv.Value);
if (prop.arraySize > 0)
{
PropertyField(prop.GetArrayElementAtIndex(0));
}
}
}
EditorGUI.indentLevel--;
}
protected void PropertyTwoFiled(SerializedProperty prop, SerializedProperty relativeListProp,
string labelName = null)
{
if (string.IsNullOrEmpty(labelName))
{
labelName = relativeListProp.displayName;
}
ChartEditorHelper.MakeTwoField(ref m_DrawRect, m_DefaultWidth, relativeListProp, labelName);
m_Heights[m_KeyName] += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
}
protected SerializedProperty PropertyField(string path)
{
Assert.IsNotNull(path);
var property = FindProperty(path);
Assert.IsNotNull(property, "Can't find:" + path);
var title = ChartEditorHelper.GetContent(property.displayName);
PropertyField(property, title);
return(property);
}
protected void PropertyFiledMore(System.Action action)
{
m_MoreFoldout = ChartEditorHelper.DrawHeader(MORE, m_MoreFoldout, false, null, null);
if (m_MoreFoldout)
{
if (action != null)
{
action();
}
}
}
protected void PropertyField(SerializedProperty prop, string relativePropName)
{
if (IngorePropertys.Contains(relativePropName))
{
return;
}
if (!ChartEditorHelper.PropertyField(ref m_DrawRect, m_Heights, m_KeyName, prop, relativePropName))
{
Debug.LogError("PropertyField ERROR:" + prop.displayName + ", " + relativePropName);
}
}
protected void PropertyListField(string relativePropName, bool showOrder = true, params HeaderMenuInfo[] menus)
{
var m_DrawRect = GUILayoutUtility.GetRect(1f, 17f);
var height = 0f;
var prop = FindProperty(relativePropName);
prop.isExpanded = ChartEditorHelper.MakeListWithFoldout(ref m_DrawRect, ref height,
prop, prop.isExpanded, showOrder, true, menus);
if (prop.isExpanded)
{
GUILayoutUtility.GetRect(1f, height - 17);
}
}
protected bool MakeFoldout(SerializedProperty prop, string relativePropName)
{
if (string.IsNullOrEmpty(relativePropName))
{
return(ChartEditorHelper.MakeFoldout(ref m_DrawRect, m_Heights, m_PropToggles, m_KeyName,
m_DisplayName, null));
}
else
{
var relativeProp = prop.FindPropertyRelative(relativePropName);
return(ChartEditorHelper.MakeFoldout(ref m_DrawRect, m_Heights, m_PropToggles, m_KeyName,
m_DisplayName, relativeProp));
}
}
protected void PropertyListField(SerializedProperty prop, string relativePropName, bool showOrder = true)
{
if (IngorePropertys.Contains(relativePropName))
{
return;
}
var height = m_Heights[m_KeyName];
var toggleKeyName = m_KeyName + relativePropName;
m_DataToggles[toggleKeyName] = ChartEditorHelper.MakeListWithFoldout(ref m_DrawRect, ref height,
prop.FindPropertyRelative(relativePropName),
m_DataToggles.ContainsKey(toggleKeyName) && m_DataToggles[toggleKeyName], showOrder, true);
m_Heights[m_KeyName] = height;
}
protected void PropertyField(string path)
{
var property = FindProperty(path);
if (property != null)
{
var title = ChartEditorHelper.GetContent(property.displayName);
PropertyField(property, title);
}
else
{
Debug.LogError("Property not exist:" + baseProperty.propertyPath + "," + path);
}
}
protected bool MakeComponentFoldout(SerializedProperty prop, string relativePropName, bool relativePropEnable,
params HeaderMenuInfo[] menus)
{
if (string.IsNullOrEmpty(relativePropName))
{
return(ChartEditorHelper.MakeComponentFoldout(ref m_DrawRect, m_Heights, m_PropToggles, m_KeyName,
m_DisplayName, null, null, relativePropEnable, menus));
}
else
{
var relativeProp = prop.FindPropertyRelative(relativePropName);
return(ChartEditorHelper.MakeComponentFoldout(ref m_DrawRect, m_Heights, m_PropToggles, m_KeyName,
m_DisplayName, relativeProp, null, relativePropEnable, menus));
}
}
public void OnGUI()
{
if (chart == null)
{
return;
}
if (chart.debug.foldSeries)
{
m_SerieFoldout = ChartEditorHelper.DrawHeader("Series", m_SerieFoldout, false, null, null);
if (m_SerieFoldout)
{
DrawSeries();
}
}
else
{
DrawSeries();
}
}
public static bool MakeListWithFoldout(ref Rect drawRect, ref float height, SerializedProperty listProp,
bool foldout, bool showOrder, bool showSize, params HeaderMenuInfo[] menus)
{
var rawWidth = drawRect.width;
var headerHeight = DrawSplitterAndBackground(drawRect);
var foldoutRect = drawRect;
foldoutRect.xMax -= 10;
bool flag = EditorGUI.Foldout(foldoutRect, foldout, listProp.displayName, true);
ChartEditorHelper.DrawMenu(drawRect, menus);
height += headerHeight;
drawRect.y += headerHeight;
drawRect.width = rawWidth;
if (flag)
{
MakeList(ref drawRect, ref height, listProp, showOrder, showSize);
}
return(flag);
}
protected virtual void OnStartInspectorGUI()
{
ShowVersion();
m_BaseFoldout = ChartEditorHelper.DrawHeader("Base", m_BaseFoldout, false, null, null);
if (m_BaseFoldout)
{
EditorGUILayout.PropertyField(m_Script);
EditorGUILayout.PropertyField(m_ChartName);
EditorGUILayout.PropertyField(m_RaycastTarget);
if (XChartsMgr.IsRepeatChartName(m_Chart, m_ChartName.stringValue))
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.HelpBox("chart name is repeated: " + m_ChartName.stringValue, MessageType.Error);
EditorGUILayout.EndHorizontal();
}
}
EditorGUILayout.PropertyField(m_Theme);
EditorGUILayout.PropertyField(m_Settings);
m_ComponentList.OnGUI();
m_SerieList.OnGUI();
}
void DrawSeries()
{
for (int i = 0; i < m_Editors.Count; i++)
{
var editor = m_Editors[i];
string title = editor.GetDisplayTitle();
bool displayContent = ChartEditorHelper.DrawHeader(
title,
editor.baseProperty,
editor.showProperty,
editor.menus);
if (displayContent)
{
editor.OnInternalInspectorGUI();
}
}
if (m_Editors.Count <= 0)
{
EditorGUILayout.HelpBox("No serie.", MessageType.Info);
}
}
private void AddSerie()
{
if (GUILayout.Button(Styles.btnAddSerie))
{
var menu = new GenericMenu();
foreach (var type in GetSerieTypeNames())
{
var title = ChartEditorHelper.GetContent(type.Name);
if (m_Chart.CanAddSerie(type))
{
menu.AddItem(title, false, () =>
{
m_SerieList.AddSerie(type);
});
}
else
{
menu.AddDisabledItem(title);
}
}
menu.ShowAsContext();
}
}
private void DrawSerieData(int dimension, SerializedProperty m_Datas, int index, bool showName)
{
bool flag;
if (!m_DataElementFoldout.TryGetValue(index, out flag))
{
flag = false;
m_DataElementFoldout[index] = false;
}
var fieldCount = dimension + (showName ? 1 : 0);
m_DataElementFoldout[index] = ChartEditorHelper.DrawHeader("SerieData " + index, flag, false, null,
delegate(Rect drawRect)
{
//drawRect.width -= 2f;
var maxX = drawRect.xMax;
var currentWidth = drawRect.width;
var lastX = drawRect.x;
var lastWid = drawRect.width;
var lastFieldWid = EditorGUIUtility.fieldWidth;
var lastLabelWid = EditorGUIUtility.labelWidth;
var serieData = m_Datas.GetArrayElementAtIndex(index);
var sereName = serieData.FindPropertyRelative("m_Name");
var data = serieData.FindPropertyRelative("m_Data");
#if UNITY_2019_3_OR_NEWER
var gap = 2;
var namegap = 3;
#else
var gap = 0;
var namegap = 0;
#endif
if (fieldCount <= 1)
{
while (2 > data.arraySize)
{
var value = data.arraySize == 0 ? index : 0;
data.arraySize++;
data.GetArrayElementAtIndex(data.arraySize - 1).floatValue = value;
}
SerializedProperty element = data.GetArrayElementAtIndex(1);
var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * 15 + gap;
drawRect.x = startX;
drawRect.xMax = maxX;
EditorGUI.PropertyField(drawRect, element, GUIContent.none);
}
else
{
var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * 15 + gap;
var dataWidTotal = (currentWidth - (startX + 20.5f + 1));
var dataWid = dataWidTotal / fieldCount;
var xWid = dataWid - 2;
for (int i = 0; i < dimension; i++)
{
var dataCount = i < 1 ? 2 : i + 1;
while (dataCount > data.arraySize)
{
var value = data.arraySize == 0 ? index : 0;
data.arraySize++;
data.GetArrayElementAtIndex(data.arraySize - 1).floatValue = value;
}
drawRect.x = startX + i * xWid;
drawRect.width = dataWid + 25;
SerializedProperty element = data.GetArrayElementAtIndex(dimension <= 1 ? 1 : i);
EditorGUI.PropertyField(drawRect, element, GUIContent.none);
}
if (showName)
{
drawRect.x = startX + (fieldCount - 1) * xWid;
drawRect.width = dataWid + 40 + dimension * namegap - 2.5f;
EditorGUI.PropertyField(drawRect, sereName, GUIContent.none);
}
EditorGUIUtility.fieldWidth = lastFieldWid;
EditorGUIUtility.labelWidth = lastLabelWid;
}
});
if (m_DataElementFoldout[index])
{
if (!(serie is ISimplifiedSerie))
{
DrawSerieDataDetail(m_Datas, index);
}
}
}
private void PropertyFieldData()
{
m_DataFoldout = ChartEditorHelper.DrawHeader("Data", m_DataFoldout, false, null, null,
new HeaderMenuInfo("Import ECharts Data", () =>
{
PraseExternalDataEditor.UpdateData(chart, serie, null);
PraseExternalDataEditor.ShowWindow();
}));
if (!m_DataFoldout)
{
return;
}
EditorGUI.indentLevel++;
var m_Datas = FindProperty("m_Data");
var m_DataDimension = FindProperty("m_ShowDataDimension");
var m_ShowDataName = FindProperty("m_ShowDataName");
PropertyField(m_ShowDataName);
PropertyField(m_DataDimension);
var listSize = m_Datas.arraySize;
listSize = EditorGUILayout.IntField("Size", listSize);
if (listSize < 0)
{
listSize = 0;
}
if (m_DataDimension.intValue < 1)
{
m_DataDimension.intValue = 1;
}
int dimension = m_DataDimension.intValue;
bool showName = m_ShowDataName.boolValue;
if (listSize != m_Datas.arraySize)
{
while (listSize > m_Datas.arraySize)
{
m_Datas.arraySize++;
}
while (listSize < m_Datas.arraySize)
{
m_Datas.arraySize--;
}
}
if (listSize > 30) // && !XCSettings.editorShowAllListData)
{
int num = listSize > 10 ? 10 : listSize;
for (int i = 0; i < num; i++)
{
DrawSerieData(dimension, m_Datas, i, showName);
}
if (num >= 10)
{
ChartEditorHelper.DrawHeader("... ", false, false, null, null);
DrawSerieData(dimension, m_Datas, listSize - 1, showName);
}
}
else
{
for (int i = 0; i < m_Datas.arraySize; i++)
{
DrawSerieData(dimension, m_Datas, i, showName);
}
}
EditorGUI.indentLevel--;
}
