private void DrawTypeReferenceField(Rect position, SerializedProperty property)
{
var typeOptionsAttribute = attribute as TypeOptionsAttribute ?? TypeOptionsAttribute.Default;
var serializedTypeRef = new SerializedTypeReference(property);
var selectedType = TypeCache.GetType(serializedTypeRef.TypeNameAndAssembly);
if (selectedType != null && !typeOptionsAttribute.MatchesRequirements(selectedType))
{
Debug.Log($"{property.name} had the {selectedType} value but the type does not match " +
"constraints set in the attribute, so it was set to null.");
selectedType = null;
serializedTypeRef.TypeNameAndAssembly = string.Empty;
}
var dropdownDrawer = new TypeDropdownDrawer(selectedType, typeOptionsAttribute, fieldInfo?.DeclaringType);
var fieldDrawer = new TypeFieldDrawer(
serializedTypeRef,
position,
dropdownDrawer,
typeOptionsAttribute.ShortName,
typeOptionsAttribute.UseBuiltInNames);
fieldDrawer.Draw();
}
private Argument_v1 ParseRegisterSequence(RegisterStorage reg, string type)
{
++idx;
string w2 = GetNextWord();
if (w2 == null)
{
return(null);
}
RegisterStorage reg2;
if (!arch.TryGetRegister(w2, out reg2))
{
return(null);
}
var seqArgName = reg.Name + "_" + reg2.Name;
var seqArgType = new SerializedTypeReference {
TypeName = type
};
var seqKind = new SerializedSequence();
seqKind.Registers = new Register_v1[] {
new Register_v1(reg.Name),
new Register_v1(reg2.Name)
};
return(new Argument_v1(seqArgName, seqArgType, seqKind, false));
}
public void AddGroupDrawerHandler(SerializedTypeReference drawerReference)
{
if (groupDrawerHandlers == null)
{
groupDrawerHandlers = new List <SerializedTypeReference>();
}
groupDrawerHandlers.Add(drawerReference);
}
public void AddAreaDrawerHandler(SerializedTypeReference drawerReference)
{
if (areaDrawerHandlers == null)
{
areaDrawerHandlers = new List <SerializedTypeReference>();
}
areaDrawerHandlers.Add(drawerReference);
}
public void AddTargetTypeDrawerHandler(SerializedTypeReference drawerReference)
{
if (targetTypeDrawerHandlers == null)
{
targetTypeDrawerHandlers = new List <SerializedTypeReference>();
}
targetTypeDrawerHandlers.Add(drawerReference);
}
public void AddDecoratorDrawerHandler(SerializedTypeReference drawerReference)
{
if (decoratorDrawerHandlers == null)
{
decoratorDrawerHandlers = new List <SerializedTypeReference>();
}
decoratorDrawerHandlers.Add(drawerReference);
}
public void AddPropertyDrawerHandler(SerializedTypeReference drawerReference)
{
if (propertyDrawerHandlers == null)
{
propertyDrawerHandlers = new List <SerializedTypeReference>();
}
propertyDrawerHandlers.Add(drawerReference);
}
public void AddCollectionDrawerHandler(SerializedTypeReference drawerReference)
{
if (conditionDrawerHandlers == null)
{
collectionDrawerHandlers = new List <SerializedTypeReference>();
}
collectionDrawerHandlers.Add(drawerReference);
}
public void AddPropertyHandler(SerializedTypeReference attributeHandler)
{
if (propertyHandlers == null)
{
propertyHandlers = new List <SerializedTypeReference>();
}
propertyHandlers.Add(attributeHandler);
}
public DataType VisitTypeReference(SerializedTypeReference typeReference)
{
DataType type;
if (types.TryGetValue(typeReference.TypeName, out type))
{
return(new TypeReference(typeReference.TypeName, type));
}
return(new TypeReference(typeReference.TypeName, new UnknownType()));
}
public TypeFieldDrawer(
SerializedTypeReference serializedTypeRef,
Rect position,
TypeDropdownDrawer dropdownDrawer,
bool showShortName)
{
_serializedTypeRef = serializedTypeRef;
_position = position;
_dropdownDrawer = dropdownDrawer;
_showShortName = showShortName;
}
/// <summary>
/// Draws property using provided <see cref="Rect"/>.
/// </summary>
/// <param name="position"></param>
/// <param name="property"></param>
/// <param name="label"></param>
protected override void OnGUISafe(Rect position, SerializedProperty property, GUIContent label)
{
var refAttribute = Attribute;
var refProperty = property.FindPropertyRelative("classReference");
//validate serialized data
if (refAttribute == null || refAttribute.AssemblyType == null)
{
EditorGUI.PropertyField(position, refProperty, label);
return;
}
var refType = !string.IsNullOrEmpty(refProperty.stringValue) ? Type.GetType(refProperty.stringValue) : null;
var refTypes = new List <Type>();
var refLabels = new List <string>()
{
"<None>"
};
var index = -1;
//get stored types if possible or create new item
if (!filteredTypes.TryGetValue(refAttribute.AssemblyType, out refTypes))
{
refTypes = filteredTypes[refAttribute.AssemblyType] = refAttribute.GetFilteredTypes();
}
else
{
refTypes = filteredTypes[refAttribute.AssemblyType];
}
//create labels from filtered types
for (int i = 0; i < refTypes.Count; i++)
{
var menuType = refTypes[i];
var menuLabel = FormatGroupedTypeName(menuType, refAttribute.Grouping);
if (menuType == refType)
{
index = i;
}
refLabels.Add(menuLabel);
}
//draw reference property
EditorGUI.BeginProperty(position, label, refProperty);
label = property.name != "data" ? label : GUIContent.none;
index = EditorGUI.Popup(position, label.text, index + 1, refLabels.ToArray());
//get correct class reference, index = 0 is reserved to <None> type
refProperty.stringValue = index >= 1 ? SerializedTypeReference.GetClassReference(refTypes[index - 1]) : "";
EditorGUI.EndProperty();
}
public SerializedTypeReference ParseStructure(List <Argument_v1> compoundArgs)
{
var q = ParseQualification();
var tr = new SerializedTypeReference
{
TypeName = q.Last(),
Scope = q.Take(q.Length - 1).ToArray()
};
compoundArgs.Add(new Argument_v1 {
Type = tr
});
return(tr);
}
public TypeFieldDrawer(
SerializedTypeReference serializedTypeRef,
Rect position,
TypeDropdownDrawer dropdownDrawer,
bool showShortName,
Action <Type> onTypeSelected = null,
bool triggerDropdown = false)
{
_serializedTypeRef = serializedTypeRef;
_position = position;
_dropdownDrawer = dropdownDrawer;
_showShortName = showShortName;
_onTypeSelected = onTypeSelected;
_triggerDropdown = triggerDropdown;
}
/// <summary>
/// Reads a qualification followed by '@'.
/// </summary>
/// <returns></returns>
public string[] ParseQualification()
{
var qualifiers = new List <string>();
SerializedType[] typeArgs = null;
while (i < str.Length && !PeekAndDiscard('@'))
{
string name = ParseAtName();
if (name.StartsWith("?$"))
{
name = name.Substring(2);
namesSeen.Add(name);
var oldNames = namesSeen;
if (templateNamesSeen == null)
{
templateNamesSeen = new List <string> {
name
};
}
else
{
templateNamesSeen.Add(name);
}
namesSeen = templateNamesSeen;
typeArgs = ParseTemplateArguments().ToArray(); ///$TODO: what to do about these if they're nested?
namesSeen = oldNames;
}
else
{
namesSeen.Add(name);
}
qualifiers.Insert(0, name);
}
var tr = new SerializedTypeReference
{
TypeName = qualifiers.Last(),
Scope = qualifiers.Take(qualifiers.Count - 1).ToArray(),
TypeArguments = typeArgs
};
return(qualifiers.ToArray());
}
public StringBuilder VisitTypeReference(SerializedTypeReference typeReference)
{
sb.Append(typeReference.TypeName);
if (name != null)
{
sb.AppendFormat(" {0}", name);
}
if (typeReference.TypeArguments != null && typeReference.TypeArguments.Length > 0)
{
sb.Append("<");
var sep = "";
foreach (var tyArg in typeReference.TypeArguments)
{
sb.Append(sep);
tyArg.Accept(this);
sep = ",";
}
sb.Append(">");
}
return(sb);
}
public void RemoveGroupDrawerHandler(SerializedTypeReference drawerReference)
{
groupDrawerHandlers?.Remove(drawerReference);
}
public void RemovePropertyHandler(SerializedTypeReference attributeHandler)
{
propertyHandlers?.Remove(attributeHandler);
}
public int VisitTypeReference(SerializedTypeReference typeReference)
{
return(converter.NamedTypes[typeReference.TypeName].Accept(this));
}
private Argument_v1 ParseRegisterSequence(RegisterStorage reg, string type)
{
++idx;
string w2 = GetNextWord();
if (w2 == null)
return null;
RegisterStorage reg2;
if (!arch.TryGetRegister(w2, out reg2))
return null;
var seqArgName = reg.Name + "_" + reg2.Name;
var seqArgType = new SerializedTypeReference { TypeName = type };
var seqKind = new SerializedSequence();
seqKind.Registers = new Register_v1[]{
new Register_v1(reg.Name),
new Register_v1(reg2.Name)
};
return new Argument_v1(seqArgName, seqArgType, seqKind, false);
}
public void RemoveAreaDrawerHandler(SerializedTypeReference drawerReference)
{
areaDrawerHandlers?.Remove(drawerReference);
}
public int VisitTypeReference(SerializedTypeReference typeReference)
{
return(typedefs[typeReference.TypeName].Accept(this));
}
public void RemoveDecoratorDrawerHandler(SerializedTypeReference drawerReference)
{
decoratorDrawerHandlers?.Remove(drawerReference);
}
/// <summary>
/// Reads a qualification followed by '@'.
/// </summary>
/// <returns></returns>
public string[] ParseQualification()
{
var qualifiers = new List<string>();
SerializedType[] typeArgs = null;
while (i < str.Length && !PeekAndDiscard('@'))
{
string name = ParseAtName();
if (name.StartsWith("?$"))
{
name = name.Substring(2);
namesSeen.Add(name);
var oldNames = namesSeen;
if (templateNamesSeen == null)
{
templateNamesSeen = new List<string> { name };
}
else
templateNamesSeen.Add(name);
namesSeen = templateNamesSeen;
typeArgs = ParseTemplateArguments().ToArray(); ///$TODO: what to do about these if they're nested?
namesSeen = oldNames;
}
else
{
namesSeen.Add(name);
}
qualifiers.Insert(0, name);
}
var tr = new SerializedTypeReference
{
TypeName = qualifiers.Last(),
Scope = qualifiers.Take(qualifiers.Count - 1).ToArray(),
TypeArguments = typeArgs
};
return qualifiers.ToArray();
}
public void RemoveCollectionDrawerHandler(SerializedTypeReference drawerReference)
{
collectionDrawerHandlers?.Remove(drawerReference);
}
public void RemovePropertyDrawerHandler(SerializedTypeReference drawerReference)
{
propertyDrawerHandlers?.Remove(drawerReference);
}
private void OnTypeSelected(object userData)
{
selectedClassRef = SerializedTypeReference.GetClassReference(userData as Type);
EditorWindow.focusedWindow.SendEvent(EditorGUIUtility.CommandEvent("TypeReferenceUpdated"));
}
public void RemoveTargetTypeDrawerHandler(SerializedTypeReference drawerReference)
{
targetTypeDrawerHandlers?.Remove(drawerReference);
}
/// <summary>
/// Draws property using provided <see cref="Rect"/>.
/// </summary>
/// <param name="rect"></param>
/// <param name="property"></param>
/// <param name="label"></param>
public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
{
var refAttribute = Attribute;
var refProperty = property.FindPropertyRelative("classReference");
if (refProperty == null)
{
Debug.LogWarning(property.name + " property in " + property.serializedObject.targetObject +
" - " + attribute.GetType() + " can be used only on string properties.");
EditorGUI.PropertyField(rect, property, label);
return;
}
if (refAttribute == null || refAttribute.AssemblyType == null)
{
EditorGUI.PropertyField(rect, refProperty, label);
return;
}
//DrawTypeSelectionRect(position, refProperty, refAttribute, label);
var refType = ResolveType(refProperty.stringValue);
var refTypes = new List <Type>();
var refLabels = new List <string>()
{
"<None>"
};
var index = -1;
//get stored types if possible or create new item
if (!filteredTypes.TryGetValue(refAttribute.AssemblyType, out refTypes))
{
refTypes = filteredTypes[refAttribute.AssemblyType] = refAttribute.GetFilteredTypes();
}
else
{
refTypes = filteredTypes[refAttribute.AssemblyType];
}
//create labels from filtered types
for (int i = 0; i < refTypes.Count; i++)
{
var menuType = refTypes[i];
var menuLabel = FormatGroupedTypeName(menuType, refAttribute.Grouping);
if (menuType == refType)
{
index = i;
}
refLabels.Add(menuLabel);
}
//draw reference property
EditorGUI.BeginProperty(rect, label, refProperty);
label = property.name != "data" ? label : GUIContent.none;
index = EditorGUI.Popup(rect, label.text, index + 1, refLabels.ToArray());
//get correct class reference, index = 0 is reserved to <None> type
refProperty.stringValue = index >= 1 ? SerializedTypeReference.GetClassReference(refTypes[index - 1]) : "";
EditorGUI.EndProperty();
}
public SerializedTypeReference ParseStructure(List<Argument_v1> compoundArgs)
{
var q = ParseQualification();
var tr = new SerializedTypeReference
{
TypeName = q.Last(),
Scope = q.Take(q.Length - 1).ToArray()
};
compoundArgs.Add(new Argument_v1 { Type = tr });
return tr;
}
public bool VisitTypeReference(SerializedTypeReference typeReference)
{
throw new NotImplementedException();
}
