/// <summary>
/// OnGUI implementation for ValueTuple DebugUIDrawer.
/// </summary>
/// <param name="widget">DebugUI Widget.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
/// <returns>The state of the widget.</returns>
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.ValueTuple>(widget);
var labelRect = PrepareControlRect();
EditorGUI.PrefixLabel(labelRect, EditorGUIUtility.TrTextContent(w.displayName));
// Following layout should match DebugUIDrawerFoldout to make column labels align
Rect drawRect = GUILayoutUtility.GetLastRect();
int indent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0; //be at left of rects
for (int i = 0; i < w.numElements; i++)
{
var columnRect = drawRect;
columnRect.x += EditorGUIUtility.labelWidth + i * DebugWindow.Styles.foldoutColumnWidth;
columnRect.width = DebugWindow.Styles.foldoutColumnWidth;
var value = w.values[i].GetValue();
EditorGUI.LabelField(columnRect, w.values[i].FormatString(value));
}
EditorGUI.indentLevel = indent;
return(true);
}
/// <summary>
/// OnGUI implementation for ObjectPopup DebugUIDrawer.
/// </summary>
/// <param name="widget">DebugUI Widget.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
/// <returns>If the UI can be drawn</returns>
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.ObjectPopupField>(widget);
var s = Cast <DebugStateObject>(state);
var rect = PrepareControlRect();
rect = EditorGUI.PrefixLabel(rect, EditorGUIUtility.TrTextContent(widget.displayName, w.tooltip));
var elements = w.getObjects();
if (elements?.Any() ?? false)
{
var selectedValue = w.GetValue();
var elementsArrayNames = elements.Select(e => e.name).ToArray();
var elementsArrayIndices = Enumerable.Range(0, elementsArrayNames.Length).ToArray();
var selectedIndex = selectedValue != null?Array.IndexOf(elementsArrayNames, selectedValue.name) : 0;
var newSelectedIndex = EditorGUI.IntPopup(rect, selectedIndex, elementsArrayNames, elementsArrayIndices);
if (selectedIndex != newSelectedIndex)
{
Apply(w, s, elements.ElementAt(newSelectedIndex));
}
}
else
{
EditorGUI.LabelField(rect, "Can't draw an empty enumeration.");
}
return(true);
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Field = CastWidget <DebugUI.ColorField>();
m_Container = GetComponent <DebugUIHandlerContainer>();
nameLabel.text = m_Field.displayName;
fieldR.getter = () => m_Field.GetValue().r;
fieldR.setter = x => SetValue(x, r: true);
fieldR.nextUIHandler = fieldG;
SetupSettings(fieldR);
fieldG.getter = () => m_Field.GetValue().g;
fieldG.setter = x => SetValue(x, g: true);
fieldG.previousUIHandler = fieldR;
fieldG.nextUIHandler = fieldB;
SetupSettings(fieldG);
fieldB.getter = () => m_Field.GetValue().b;
fieldB.setter = x => SetValue(x, b: true);
fieldB.previousUIHandler = fieldG;
fieldB.nextUIHandler = m_Field.showAlpha ? fieldA : null;
SetupSettings(fieldB);
fieldA.gameObject.SetActive(m_Field.showAlpha);
fieldA.getter = () => m_Field.GetValue().a;
fieldA.setter = x => SetValue(x, a: true);
fieldA.previousUIHandler = fieldB;
SetupSettings(fieldA);
UpdateColor();
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Field = CastWidget <DebugUI.BitField>();
m_Container = GetComponent <DebugUIHandlerContainer>();
nameLabel.text = m_Field.displayName;
int toggleIndex = 0;
foreach (var enumName in m_Field.enumNames)
{
if (toggleIndex >= toggles.Count)
{
continue;
}
var toggle = toggles[toggleIndex];
toggle.getter = GetValue;
toggle.setter = SetValue;
toggle.nextUIHandler = toggleIndex < (m_Field.enumNames.Length - 1) ? toggles[toggleIndex + 1] : null;
toggle.previousUIHandler = toggleIndex > 0 ? toggles[toggleIndex - 1] : null;
toggle.parentUIHandler = this;
toggle.index = toggleIndex;
toggle.nameLabel.text = enumName.text;
toggle.Init();
toggleIndex++;
}
;
for (; toggleIndex < toggles.Count; ++toggleIndex)
{
toggles[toggleIndex].transform.SetParent(null);
}
}
internal override void SetWidget(DebugUI.Widget widget)
{
m_Widget = widget;
m_Field = CastWidget <DebugUI.ValueTuple>();
nameLabel.text = m_Field.displayName;
Debug.Assert(m_Field.numElements > 0);
int numElements = m_Field.numElements;
valueElements = new Text[numElements];
valueElements[0] = valueLabel;
float columnOffset = k_XOffset / (float)numElements;
for (int index = 1; index < numElements; ++index)
{
var valueElement = Instantiate(valueLabel.gameObject, transform);
valueElement.AddComponent <LayoutElement>().ignoreLayout = true;
var rectTransform = valueElement.transform as RectTransform;
var originalTransform = nameLabel.transform as RectTransform;
rectTransform.anchorMax = rectTransform.anchorMin = new Vector2(0, 1);
rectTransform.sizeDelta = new Vector2(100, 26);
Vector3 pos = originalTransform.anchoredPosition;
pos.x += (index + 1) * columnOffset + 200f;
rectTransform.anchoredPosition = pos;
rectTransform.pivot = new Vector2(0, 1);
valueElements[index] = valueElement.GetComponent <Text>();
}
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Value = CastWidget <DebugUI.ProgressBarValue>();
nameLabel.text = m_Value.displayName;
UpdateValue();
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Field = CastWidget <DebugUI.Vector4Field>();
m_Container = GetComponent <DebugUIHandlerContainer>();
nameLabel.text = m_Field.displayName;
fieldX.getter = () => m_Field.GetValue().x;
fieldX.setter = x => SetValue(x, x: true);
fieldX.nextUIHandler = fieldY;
SetupSettings(fieldX);
fieldY.getter = () => m_Field.GetValue().y;
fieldY.setter = x => SetValue(x, y: true);
fieldY.previousUIHandler = fieldX;
fieldY.nextUIHandler = fieldZ;
SetupSettings(fieldY);
fieldZ.getter = () => m_Field.GetValue().z;
fieldZ.setter = x => SetValue(x, z: true);
fieldZ.previousUIHandler = fieldY;
fieldZ.nextUIHandler = fieldW;
SetupSettings(fieldZ);
fieldW.getter = () => m_Field.GetValue().w;
fieldW.setter = x => SetValue(x, w: true);
fieldW.previousUIHandler = fieldZ;
SetupSettings(fieldW);
}
void OnWidgetGUI(DebugUI.Widget widget)
{
if (widget.isRuntimeOnly)
{
return;
}
DebugState state; // State will be null for stateless widget
m_WidgetStates.TryGetValue(widget.queryPath, out state);
DebugUIDrawer drawer;
if (!s_WidgetDrawerMap.TryGetValue(widget.GetType(), out drawer))
{
EditorGUILayout.LabelField("Drawer not found (" + widget.GetType() + ").");
}
else
{
drawer.Begin(widget, state);
if (drawer.OnGUI(widget, state))
{
var container = widget as DebugUI.IContainer;
if (container != null)
{
TraverseContainerGUI(container);
}
}
drawer.End(widget, state);
}
}
public override void Begin(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.Foldout>(widget);
var s = Cast <DebugStateBool>(state);
EditorGUI.BeginChangeCheck();
Rect rect = PrepareControlRect();
bool value = EditorGUI.Foldout(rect, w.GetValue(), EditorGUIUtility.TrTextContent(w.displayName), true);
Rect drawRect = GUILayoutUtility.GetLastRect();
if (w.columnLabels != null && value)
{
const int oneColumnWidth = 60;
int indent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0; //be at left of rects
for (int i = 0; i < w.columnLabels.Length; i++)
{
var columnRect = drawRect;
columnRect.x += EditorGUIUtility.labelWidth + i * oneColumnWidth;
columnRect.width = oneColumnWidth;
EditorGUI.LabelField(columnRect, w.columnLabels[i] ?? "", EditorStyles.miniBoldLabel);
}
EditorGUI.indentLevel = indent;
}
if (EditorGUI.EndChangeCheck())
{
Apply(w, s, value);
}
EditorGUI.indentLevel++;
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Field = CastWidget <DebugUI.BitField>();
m_Container = GetComponent <DebugUIHandlerContainer>();
nameLabel.text = m_Field.displayName;
int toggleIndex = 0;
foreach (var enumName in m_Field.enumNames)
{
if (toggleIndex >= toggles.Count)
{
continue;
}
var toggle = toggles[toggleIndex];
toggle.getter = GetValue;
toggle.setter = SetValue;
toggle.nextUIHandler = toggleIndex < (m_Field.enumNames.Length - 1) ? toggles[toggleIndex + 1] : null;
toggle.previousUIHandler = toggleIndex > 0 ? toggles[toggleIndex - 1] : null;
toggle.parentUIHandler = this;
toggle.index = toggleIndex;
toggle.nameLabel.text = enumName.text;
toggle.Init();
toggleIndex++;
}
// Destroy the remaining toggles outside of the range of the displayed enum.
for (; toggleIndex < toggles.Count; ++toggleIndex)
{
CoreUtils.Destroy(toggles[toggleIndex].gameObject);
toggles[toggleIndex] = null;
}
}
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.EnumField>(widget);
var s = Cast <DebugStateInt>(state);
EditorGUI.BeginChangeCheck();
int value = w.GetValue();
if (w.enumNames == null || w.enumValues == null)
{
EditorGUILayout.LabelField("Can't draw an empty enumeration.");
}
else
{
var rect = PrepareControlRect();
int index = Array.IndexOf(w.enumValues, w.GetValue());
// Fallback just in case, we may be handling sub/sectionned enums here
if (index < 0)
{
value = w.enumValues[0];
}
value = EditorGUI.IntPopup(rect, CoreEditorUtils.GetContent(w.displayName), value, w.enumNames, w.enumValues);
}
if (EditorGUI.EndChangeCheck())
{
Apply(w, s, value);
}
return(true);
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Field = CastWidget <DebugUI.EnumField>();
nameLabel.text = m_Field.displayName;
UpdateValueLabel();
}
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.EnumField>(widget);
var s = Cast <DebugStateInt>(state);
EditorGUI.BeginChangeCheck();
int value = s.value;
if (w.enumNames == null || w.enumValues == null)
{
EditorGUILayout.LabelField("Can't draw an empty enumeration.");
}
else
{
var rect = PrepareControlRect();
value = EditorGUI.IntPopup(rect, CoreEditorUtils.GetContent(w.displayName), s.value, w.enumNames, w.enumValues);
}
if (EditorGUI.EndChangeCheck())
{
Apply(w, s, value);
}
return(true);
}
/// <summary>
/// OnGUI implementation for Bitfield DebugUIDrawer.
/// </summary>
/// <param name="widget">DebugUI Widget.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
/// <returns>The state of the widget.</returns>
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.BitField>(widget);
var s = Cast <DebugStateFlags>(state);
EditorGUI.BeginChangeCheck();
Enum value = w.GetValue();
var rect = PrepareControlRect();
// Skip first element (with value 0) because EditorGUI.MaskField adds a 'Nothing' field anyway
var enumNames = new string[w.enumNames.Length - 1];
for (int i = 0; i < enumNames.Length; i++)
{
enumNames[i] = w.enumNames[i + 1].text;
}
var index = EditorGUI.MaskField(rect, EditorGUIUtility.TrTextContent(w.displayName, w.tooltip), (int)Convert.ToInt32(value), enumNames);
value = Enum.Parse(value.GetType(), index.ToString()) as Enum;
if (EditorGUI.EndChangeCheck())
{
Apply(w, s, value);
}
return(true);
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Field = CastWidget <DebugUI.Foldout>();
m_Container = GetComponent <DebugUIHandlerContainer>();
nameLabel.text = m_Field.displayName;
int columnNumber = m_Field.columnLabels?.Length ?? 0;
for (int index = 0; index < columnNumber; ++index)
{
var column = Instantiate(nameLabel.gameObject, GetComponent <DebugUIHandlerContainer>().contentHolder);
column.AddComponent <LayoutElement>().ignoreLayout = true;
var rectTransform = column.transform as RectTransform;
var originalTransform = nameLabel.transform as RectTransform;
rectTransform.anchorMax = rectTransform.anchorMin = new Vector2(0, 1);
rectTransform.sizeDelta = new Vector2(100, 26);
Vector3 pos = originalTransform.anchoredPosition;
pos.x += (index + 1) * xDecal + xDecalInit;
rectTransform.anchoredPosition = pos;
rectTransform.pivot = new Vector2(0, 0.5f);
rectTransform.eulerAngles = new Vector3(0, 0, 13);
var text = column.GetComponent <Text>();
text.fontSize = 15;
text.text = m_Field.columnLabels[index];
}
UpdateValue();
}
/// <summary>
/// Begin implementation for Foldout DebugUIDrawer.
/// </summary>
/// <param name="widget">DebugUI Widget.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
public override void Begin(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.Foldout>(widget);
var s = Cast <DebugStateBool>(state);
EditorGUI.BeginChangeCheck();
GUIStyle style = w.isHeader ? DebugWindow.Styles.foldoutHeaderStyle : EditorStyles.foldout;
Rect rect = PrepareControlRect(w.isHeader ? style.fixedHeight : -1, w.isHeader);
if (w.isHeader)
{
GUILayout.Space(k_HeaderVerticalMargin);
}
bool value = EditorGUI.Foldout(rect, w.GetValue(), EditorGUIUtility.TrTextContent(w.displayName, w.tooltip), false, style);
if (EditorGUI.EndChangeCheck())
{
Apply(w, s, value);
}
if (w.contextMenuItems != null)
{
float contextMenuButtonSize = style.fixedHeight;
var labelRect = EditorGUI.IndentedRect(GUILayoutUtility.GetRect(0f, /*17f*/ 0f));
labelRect.xMax -= 20f + 16 + 5;
var contextMenuRect = new Rect(labelRect.xMax + 3f + 16, labelRect.y - contextMenuButtonSize, contextMenuButtonSize, contextMenuButtonSize);
if (GUI.Button(contextMenuRect, CoreEditorStyles.contextMenuIcon, CoreEditorStyles.contextMenuStyle))
{
var menu = new GenericMenu();
foreach (var item in w.contextMenuItems)
{
menu.AddItem(EditorGUIUtility.TrTextContent(item.displayName), false, () => item.action.Invoke());
}
menu.DropDown(new Rect(new Vector2(contextMenuRect.x, contextMenuRect.yMax), Vector2.zero));
}
}
Rect drawRect = GUILayoutUtility.GetLastRect();
if (w.columnLabels != null && value)
{
const int oneColumnWidth = 70;
int indent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0; //be at left of rects
for (int i = 0; i < w.columnLabels.Length; i++)
{
var columnRect = drawRect;
columnRect.x += EditorGUIUtility.labelWidth + i * oneColumnWidth;
columnRect.width = oneColumnWidth;
string label = w.columnLabels[i] ?? "";
string tooltip = w.columnTooltips?.ElementAtOrDefault(i) ?? "";
EditorGUI.LabelField(columnRect, EditorGUIUtility.TrTextContent(label, tooltip), EditorStyles.miniBoldLabel);
}
EditorGUI.indentLevel = indent;
}
EditorGUI.indentLevel++;
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Field = CastWidget <DebugUI.Foldout>();
m_Container = GetComponent <DebugUIHandlerContainer>();
nameLabel.text = m_Field.displayName;
UpdateValue();
}
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.Value>(widget);
var rect = PrepareControlRect();
EditorGUI.LabelField(rect, CoreEditorUtils.GetContent(w.displayName), CoreEditorUtils.GetContent(w.GetValue().ToString()));
return(true);
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
var field = CastWidget <DebugUI.ObjectField>();
nameLabel.text = field.displayName;
valueLabel.text = field.GetValue().name;
}
/// <summary>
/// OnGUI implementation for Value DebugUIDrawer.
/// </summary>
/// <param name="widget">DebugUI Widget.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
/// <returns>The state of the widget.</returns>
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.Value>(widget);
var rect = PrepareControlRect();
var value = w.GetValue();
EditorGUI.LabelField(rect, EditorGUIUtility.TrTextContent(w.displayName), EditorGUIUtility.TrTextContent(w.FormatString(value)));
return(true);
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Field = CastWidget <DebugUI.BoolField>();
nameLabel.text = m_Field.displayName;
UpdateValueLabel();
valueToggle.onValueChanged.AddListener(OnToggleValueChanged);
}
/// <summary>
/// Implement this to execute processing after UI rendering.
/// </summary>
/// <param name="widget">Widget that is going to be rendered.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
public override void End(DebugUI.Widget widget, DebugState state)
{
if (EditorGUI.EndChangeCheck())
{
var w = Cast <TField>(widget);
var s = Cast <TState>(state);
Apply(w, s, value);
}
}
public override void Begin(DebugUI.Widget widget, DebugState state)
{
if (!string.IsNullOrEmpty(widget.displayName))
{
EditorGUILayout.LabelField(widget.displayName, EditorStyles.boldLabel);
}
EditorGUI.indentLevel++;
}
/// <summary>
/// End implementation for Foldout DebugUIDrawer.
/// </summary>
/// <param name="widget">DebugUI Widget.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
public override void End(DebugUI.Widget widget, DebugState state)
{
EditorGUI.indentLevel--;
var w = Cast <DebugUI.Foldout>(widget);
if (w.isHeader)
{
GUILayout.Space(k_HeaderVerticalMargin);
}
}
static DebugUI.Widget[] GenerateFrameSettingsPanelContent(HDRenderPipelineAsset defaultHdrpAsset, ref FrameSettingsHistory frameSettings)
{
var panelContent = new DebugUI.Widget[foldoutNames.Length];
for (int index = 0; index < foldoutNames.Length; ++index)
{
panelContent[index] = new DebugUI.Foldout(foldoutNames[index], GenerateHistoryArea(defaultHdrpAsset, ref frameSettings, index), columnNames);
}
return(panelContent);
}
/// <summary>
/// Implement this to execute UI rendering.
/// </summary>
/// <param name="widget">Widget that is going to be rendered.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
/// <returns>Returns the state of the widget.</returns>
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
DoGUI(
PrepareControlRect(),
EditorGUIUtility.TrTextContent(widget.displayName, widget.tooltip),
Cast <TWidget>(widget)
);
return(true);
}
/// <summary>
/// OnGUI implementation for Table DebugUIDrawer.
/// </summary>
/// <param name="widget">DebugUI Widget.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
/// <returns>The state of the widget.</returns>
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.Table>(widget);
var header = w.Header;
// Put some space before the array
PrepareControlRect(EditorGUIUtility.singleLineHeight * 0.5f);
// Draw an outline around the table
var rect = EditorGUI.IndentedRect(PrepareControlRect(header.height + (w.children.Count + 1) * EditorGUIUtility.singleLineHeight));
rect = DrawOutline(rect);
// Compute rects
var headerRect = new Rect(rect.x, rect.y, rect.width, header.height);
var contentRect = new Rect(rect.x, headerRect.yMax, rect.width, rect.height - headerRect.height);
var viewRect = new Rect(contentRect.x, contentRect.y, header.state.widthOfAllVisibleColumns, contentRect.height);
var rowRect = contentRect;
rowRect.height = EditorGUIUtility.singleLineHeight;
viewRect.height -= EditorGUIUtility.singleLineHeight;
// Show header
header.OnGUI(headerRect, Mathf.Max(w.scroll.x, 0f));
// Show array content
w.scroll = GUI.BeginScrollView(contentRect, w.scroll, viewRect);
{
var columns = header.state.columns;
var visible = header.state.visibleColumns;
for (int r = 0; r < w.children.Count; r++)
{
var row = Cast <DebugUI.Container>(w.children[r]);
rowRect.x = contentRect.x;
rowRect.width = columns[0].width;
rowRect.xMin += 2;
rowRect.xMax -= 2;
EditorGUI.LabelField(rowRect, GUIContent.none, EditorGUIUtility.TrTextContent(row.displayName));
rowRect.xMin -= 2;
rowRect.xMax += 2;
for (int c = 1; c < visible.Length; c++)
{
rowRect.x += rowRect.width;
rowRect.width = columns[visible[c]].width;
DisplayChild(rowRect, row.children[visible[c] - 1], w.isReadOnly);
}
rowRect.y += rowRect.height;
}
}
GUI.EndScrollView(false);
return(false);
}
/// <summary>
/// Implement this to execute processing before UI rendering.
/// </summary>
/// <param name="widget">Widget that is going to be rendered.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
public override void Begin(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.Container>(widget);
if (!w.hideDisplayName)
{
EditorGUILayout.LabelField(EditorGUIUtility.TrTextContent(widget.displayName, widget.tooltip), EditorStyles.boldLabel);
}
EditorGUI.indentLevel++;
}
/// <summary>
/// OnGUI implementation for Value DebugUIDrawer.
/// </summary>
/// <param name="widget">DebugUI Widget.</param>
/// <param name="state">Debug State associated with the Debug Item.</param>
/// <returns>The state of the widget.</returns>
public override bool OnGUI(DebugUI.Widget widget, DebugState state)
{
var w = Cast <DebugUI.ProgressBarValue>(widget);
var labelRect = PrepareControlRect();
var progressBarRect = EditorGUI.PrefixLabel(labelRect, EditorGUIUtility.TrTextContent(w.displayName));
float value = (float)w.GetValue();
EditorGUI.ProgressBar(progressBarRect, value, w.FormatString(value));
return(true);
}
internal override void SetWidget(DebugUI.Widget widget)
{
base.SetWidget(widget);
m_Field = CastWidget <DebugUI.Container>();
m_Container = GetComponent <DebugUIHandlerContainer>();
if (string.IsNullOrEmpty(m_Field.displayName))
{
header.gameObject.SetActive(false);
}
else
{
nameLabel.text = m_Field.displayName;
}
}
