public override bool InspectSelf(Inspector inspector, string name, ref object data, Type type)
{
var e = data as Enum;
if (e == null)
{
return(false);
}
if (TypeTools.GetAttribute <FlagsAttribute>(type) != null)
{
return(ApplyValueIfNotEqual(ref data, GUITools.EnumMaskField(name, e)));
}
else
{
return(ApplyValueIfNotEqual(ref data, GUITools.EnumPopup(name, e)));
}
}
public override bool InspectSelf(Inspector inspector, string name, ref object data, Type type)
{
if (data == null)
{
GUITools.LabelField("null");
GUILayout.FlexibleSpace();
return(false);
}
if (ShowSize())
{
GUITools.LabelField("Count: " + Size(data));
}
GUILayout.FlexibleSpace();
return(false);
}
private static bool Traversal(Inspector inspector, string path, DictionaryGUIState state, int start, int end)
{
bool changed = false;
var bucketSize = Math.Max(state.display.bucketSize, 2);
var valueType = state.ValueType();
if (end - start <= bucketSize)
{
for (int index = start; index < end; ++index)
{
changed |= InspectElement(inspector, path, state.display.resultKeys[index], state, valueType);
}
}
else
{
// Allow multiple level of bucket, calculate the current step
int step = bucketSize;
while (step * bucketSize < end - start)
{
step *= bucketSize;
}
for (int inner = start; inner < end; inner += step)
{
int innerEnd = Math.Min(end, inner + step);
var innerKeyBegin = state.display.resultKeys[inner];
var innerKeyEnd = state.display.resultKeys[innerEnd - 1];
var label = FormatKeyRange(innerKeyBegin, innerKeyEnd);
var foldoutPath = path + "[" + innerKeyBegin + "~" + innerKeyEnd + "]";
inspector.isFoldout[foldoutPath] = GUITools.Foldout(inspector.isFoldout.ContainsKey(foldoutPath) && inspector.isFoldout[foldoutPath], label);
if (inspector.isFoldout[foldoutPath])
{
using (GUITools.Indent())
{
changed |= Traversal(inspector, path, state, inner, innerEnd);
}
}
}
}
return(changed);
}
public override bool InspectChildren(Inspector inspector, string path, ref object data, Type type)
{
if (data == null)
{
return(false);
}
if (Resizable(data))
{
var oldSize = Size(data);
int size = Math.Max(0, GUITools.IntField("Size", oldSize));
if (size != oldSize)
{
data = Resize(data, size);
return(true);
}
}
return(GUIContainerTools.EditDict(inspector, path, data, this));
}
public bool Inspect(string name, string path, object data,
Type type = null,
IMark mark = null,
Action <object> OnValueChanged = null)
{
if (inInspector)
{
return(InspectInternal(name, path, data, type, mark, OnValueChanged));
}
try
{
inInspector = true;
GUITools.Setup();
return(InspectInternal(name, path, data, type, mark, OnValueChanged));
}
finally
{
inInspector = false;
}
}
private static bool InspectProperty(Inspector inspector, string path, ref object data,
PropertyInfo propertyInfo)
{
if (propertyInfo.CanRead && CanInspect(propertyInfo))
{
object value;
try
{
value = propertyInfo.GetValue(data, null);
}
catch (Exception)
{
return(false);
}
return(inspector.Inspect(propertyInfo.Name, path + "." + propertyInfo.Name, value));
}
else
{
GUITools.LabelField(propertyInfo.Name, "unreadable");
return(false);
}
}
public override bool InspectChildren(Inspector inspector, string path, ref object data, Type type)
{
var time = (DateTime)data;
GUITools.LabelField("Unix Time Stamp", ToUnixTimestampString(time));
var ticks = GUITools.LongField("Ticks", time.Ticks);
var kind = (DateTimeKind)GUITools.EnumPopup("Kind", time.Kind);
if (ticks != time.Ticks || kind != time.Kind)
{
try
{
data = new DateTime(ticks, kind);
return(true);
}
catch (Exception)
{
}
}
return(false);
}
public override bool AlwaysShowChildren()
{
return(GUITools.IsInEditor() == false);
}
public override bool HasChildren()
{
return(GUITools.IsInEditor() == false);
}
// Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, and Single.
public override bool InspectSelf(Inspector inspector, string name, ref object data, Type type)
{
object result;
if (data == null)
{
GUITools.LabelField(name, "null");
result = null;
}
else if (data is bool)
{
result = (bool)GUITools.Toggle(name, (bool)data);
}
else if (data is byte)
{
result = (byte)GUITools.IntField(name, (byte)data);
}
else if (data is sbyte)
{
result = (sbyte)GUITools.IntField(name, (sbyte)data);
}
else if (data is short)
{
result = (short)GUITools.IntField(name, (short)data);
}
else if (data is ushort)
{
result = (ushort)GUITools.IntField(name, (ushort)data);
}
else if (data is int)
{
result = (int)GUITools.IntField(name, (int)data);
}
else if (data is uint)
{
result = (uint)GUITools.LongField(name, (uint)data);
}
else if (data is long)
{
result = (long)ParseLong(GUITools.TextField(name, data.ToString()), (long)data);
}
else if (data is ulong)
{
result = (ulong)ParseULong(GUITools.TextField(name, data.ToString()), (ulong)data);
}
else if (data is IntPtr)
{
GUITools.TextField(name, data.ToString());
result = data;
}
else if (data is UIntPtr)
{
GUITools.TextField(name, data.ToString());
result = data;
}
else if (data is char)
{
result = (char)ParseChar(GUITools.TextField(name, data.ToString()), (char)data);
}
else if (data is float)
{
result = (float)GUITools.FloatField(name, (float)data);
}
else if (data is double)
{
result = (double)GUITools.DoubleField(name, (double)data);
}
else
{
throw new NotImplementedException(type.Name);
}
return(ApplyValueIfNotEqual(ref data, result));
}
public override bool InspectChildren(Inspector inspector, string path, ref object data, Type type)
{
var timestamp = (int)data;
return(ApplyValueIfNotEqual(ref data, GUITools.IntField("Unix Time Stamp", timestamp)));
}
public bool InspectInternal(string name, string path, object data,
Type type = null,
IMark mark = null,
Action <object> OnValueChanged = null)
{
if (data != null)
{
type = data.GetType();
}
GUITools.SetLabelWidth(options.labelWidth);
VisualizerBase visualizer = GetVisualizer(type, mark);
bool changed = false;
object changedData = data;
if (visualizer != null)
{
string fieldinfo = name;
var postfix = visualizer.GetLabelPostfix(this, data, type);
if (postfix != null)
{
fieldinfo += postfix;
}
if (visualizer.HasChildren())
{
// Note: to avoid infinite expand that may cause by alwaysShowChildren,
// If parentAlwaysShowChild, then current node ignores alwaysShowChildren.
var parentAlwaysShowChild = parentIsAlwaysShow.Count > 0 && parentIsAlwaysShow.Peek();
bool alwaysShowChildren = !parentAlwaysShowChild && visualizer.AlwaysShowChildren();
if (!alwaysShowChildren)
{
using (GUITools.HorizontalScope())
{
var width = options.labelWidth - options.indentOffset * GUITools.GetIndentLevel();
using (GUITools.HorizontalScope(width))
{
isFoldout[path] = GUITools.Foldout(isFoldout.ContainsKey(path) && isFoldout[path], fieldinfo);
}
changed |= InspectRoot(name, type, ref changedData, visualizer, mark);
}
}
else
{
changed |= InspectRoot(name, type, ref changedData, visualizer, mark);
}
if (changedData != null && (alwaysShowChildren || isFoldout[path]))
{
try
{
parentIsAlwaysShow.Push(alwaysShowChildren);
using (GUITools.Indent())
changed |= visualizer.InspectChildren(this, path, ref changedData, type);
}
finally
{
parentIsAlwaysShow.Pop();
}
}
}
else
{
changed |= InspectRoot(fieldinfo, type, ref changedData, visualizer, mark);
}
}
if (changed && OnValueChanged != null)
{
OnValueChanged(changedData);
}
return(changed);
}