/// <summary>
/// Renders a layout editor for a NestedValue.
/// </summary>
static public NestedValue NestedValueField(NestedValue inValue, RSTypeInfo inExpectedType, RSValue inDefaultValue, RSValidationFlags inFlags, RSValidationContext inContext)
{
using (new RSGUI.LabelWidthScope(0))
{
return(DoNestedValueField(GUIContent.none, inValue, inExpectedType, inDefaultValue, inFlags, inContext));
}
}
public void PopulateDefaultArguments(RSResolvableValueData ioValue, int inStartIndex = 0)
{
if (Parameters == null || Parameters.Length == 0)
{
ioValue.QueryArguments = null;
}
else
{
Array.Resize(ref ioValue.QueryArguments, Parameters.Length);
for (int i = inStartIndex; i < Parameters.Length; ++i)
{
ioValue.QueryArguments[i] = NestedValue.FromValue(Parameters[i].Default);
}
}
}
public int GetTotalAttributes()
{
var result = propertiesCount;
if (NestedValue != null)
{
result += NestedValue.GetTotalAttributes();
}
if (NestedClasses != null)
{
foreach (var item in NestedClasses)
{
if (item != null)
{
result += item.GetTotalAttributes();
}
}
}
return(result);
}
static private void ValidateNestedValue(NestedValue inValue, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationState ioState, RSValidationContext inContext)
{
bool bDisallowDirectValue = (inExpectedType == null || inExpectedType == RSBuiltInTypes.Any || inFlags.Has(RSValidationFlags.DisallowDirectValue));
switch (inValue.Mode)
{
case ResolvableValueMode.Argument:
{
ValidateTriggerArgument(inExpectedType, inFlags, ioState, inContext);
break;
}
case ResolvableValueMode.Register:
{
if (inFlags.Has(RSValidationFlags.DisallowRegisters))
{
ioState.Error("Cannot use a register in this context");
}
break;
}
case ResolvableValueMode.Value:
{
if (bDisallowDirectValue)
{
ioState.Error("Cannot specify a direct value in this context");
}
else
{
ValidateValue(inValue.Value, inExpectedType, inFlags, ioState, inContext);
}
break;
}
case ResolvableValueMode.Query:
{
ValidateQueryId(inValue.Query, inExpectedType, inFlags.ForMethod(false), ioState, inContext);
break;
}
}
}
/// <summary>
/// Resolves argument to a value.
/// </summary>
public MultiReturn <RSValue> ResolveValue(NestedValue inArgument)
{
switch (inArgument.Mode)
{
case ResolvableValueMode.Value:
return(inArgument.Value);
case ResolvableValueMode.Argument:
return(m_Argument);
case ResolvableValueMode.Register:
return(PeekRegister(inArgument.Register));
case ResolvableValueMode.Query:
return(EvaluateQuery(inArgument.Query, null));
default:
Assert.Fail("Unrecognized argument mode {0}", inArgument.Mode);
return(RSValue.Null);
}
}
public TestClass Clone()
{
var result = new TestClass
{
Value1 = Value1,
Value2 = Value2,
Value3 = Value3,
Value4 = Value4,
NestedValue = NestedValue?.Clone(),
NestedClasses = NestedClasses == null ? null : new List <TestClass>(NestedClasses.Count)
};
if (NestedClasses != null)
{
foreach (var item in NestedClasses)
{
result.NestedClasses.Add(item?.Clone());
}
}
return(result);
}
static private void DoResolvableValueData(UndoTarget inUndo, GUIContent inLabel, RSResolvableValueData ioValue, RSTypeInfo inExpectedType, RSValue inDefaultValue, RSValidationFlags inFlags, RSValidationContext inContext)
{
EditorGUILayout.BeginVertical();
bool bDisallowDirectValue = (inExpectedType == null || inExpectedType == RSBuiltInTypes.Any || inFlags.Has(RSValidationFlags.DisallowDirectValue));
ResolvableValueMode nextMode = ListGUILayout.Popup(inLabel, ioValue.Mode, RSEditorUtility.GetResolvableValueModes(inExpectedType, inFlags, inContext));
if (nextMode != ioValue.Mode)
{
inUndo.MarkDirty("Changed Resolvable Value Mode");
ioValue.Mode = nextMode;
switch (nextMode)
{
case ResolvableValueMode.Argument:
RSResolvableValueData.SetAsArgument(ref ioValue);
break;
case ResolvableValueMode.Query:
RSResolvableValueData.SetAsQuery(ref ioValue, new EntityScopedIdentifier(EntityScopeData.Self(), 0));
break;
case ResolvableValueMode.Value:
RSResolvableValueData.SetAsValue(ref ioValue, inDefaultValue);
break;
case ResolvableValueMode.Register:
RSResolvableValueData.SetAsRegister(ref ioValue, RegisterIndex.Register0);
break;
}
}
using (new EditorGUI.IndentLevelScope())
{
switch (ioValue.Mode)
{
case ResolvableValueMode.Argument:
{
if (inContext.Trigger == null)
{
EditorGUILayout.HelpBox("No parameter available: No Trigger", MessageType.Error);
}
else if (inContext.Trigger.ParameterType == null)
{
EditorGUILayout.HelpBox(string.Format("No parameter available - Trigger {0} has no parameter", inContext.Trigger.Name), MessageType.Error);
}
else if (inExpectedType != null && !inContext.Trigger.ParameterType.Type.CanConvert(inExpectedType))
{
EditorGUILayout.HelpBox(string.Format("No parameter available - Trigger {0} has incompatible parameter type {1}, which cannot convert to {2}", inContext.Trigger.Name, inContext.Trigger.ParameterType.Type, inExpectedType), MessageType.Error);
}
break;
}
case ResolvableValueMode.Value:
{
if (bDisallowDirectValue)
{
EditorGUILayout.HelpBox("Cannot specify a value in this context", MessageType.Error);
}
else
{
RSValue nextValue = ValueGUILayout.RSValueField(EditorGUIUtility.TrTempContent(inExpectedType.FriendlyName), ioValue.Value, inExpectedType, inFlags, inContext);
if (nextValue != ioValue.Value)
{
inUndo.MarkDirty("Changed Resolvable Value Value");
ioValue.Value = nextValue;
}
}
break;
}
case ResolvableValueMode.Register:
{
RegisterIndex nextRegister = (RegisterIndex)EnumGUILayout.EnumField(Content.ResolvableValueRegisterLabel, ioValue.Register);
if (nextRegister != ioValue.Register)
{
inUndo.MarkDirty("Changed Resolvable Value Register");
ioValue.Register = nextRegister;
}
break;
}
case ResolvableValueMode.Query:
{
EntityScopedIdentifier query = ValueGUILayout.QueryField(Content.ResolvableValueQueryLabel, ioValue.Query, inExpectedType, inFlags.ForMethod(true), inContext);
RSQueryInfo queryInfo = inContext.Library.GetQuery(query.Id);
if (query != ioValue.Query)
{
bool bChangedId = query.Id != ioValue.Query.Id;
inUndo.MarkDirty("Changed Resolvable Value Query", true);
ioValue.Query = query;
if (bChangedId)
{
if (queryInfo == null)
{
ioValue.QueryArguments = null;
}
else
{
queryInfo.PopulateDefaultArguments(ioValue);
}
}
}
int currentArgsLength = 0;
if (ioValue.QueryArguments != null)
{
currentArgsLength = ioValue.QueryArguments.Length;
}
int desiredArgsLength = 0;
if (queryInfo != null && queryInfo.Parameters != null)
{
desiredArgsLength = queryInfo.Parameters.Length;
}
if (desiredArgsLength == 0 && ioValue.QueryArguments != null)
{
inUndo.MarkDirtyWithoutUndo("Resizing Arguments", true);
ioValue.QueryArguments = null;
}
else if (desiredArgsLength > 0 && currentArgsLength != desiredArgsLength)
{
inUndo.MarkDirtyWithoutUndo("Resizing Arguments", true);
queryInfo.PopulateDefaultArguments(ioValue, currentArgsLength);
}
if (ioValue.QueryArguments != null && ioValue.QueryArguments.Length > 0)
{
using (new EditorGUI.IndentLevelScope())
{
EditorGUILayout.Space();
EditorGUILayout.LabelField(Content.ResolvableValueQueryArgsLabel, RSGUIStyles.SubHeaderStyle);
for (int i = 0; i < ioValue.QueryArguments.Length && i < queryInfo.Parameters.Length; ++i)
{
NestedValue nextValue = ValueGUILayout.NestedParameterField(queryInfo.Parameters[i], ioValue.QueryArguments[i], inFlags, inContext);
if (nextValue != ioValue.QueryArguments[i])
{
inUndo.MarkDirty("Changed Resolvable Value Query Argument");
ioValue.QueryArguments[i] = nextValue;
}
}
}
}
break;
}
}
}
EditorGUILayout.EndVertical();
}
/// <summary>
/// Renders a layout editor for a NestedValue linked to a parameter.
/// </summary>
static public NestedValue NestedParameterField(RSParameterInfo inParameterInfo, NestedValue inValue, RSValidationFlags inFlags, RSValidationContext inContext)
{
RSValidationFlags flags = inFlags.ForParameter(inParameterInfo);
if (!inParameterInfo.NotNull)
{
flags |= RSValidationFlags.AllowNullEntity;
}
return(NestedValueField(EditorGUIUtility.TrTextContent(inParameterInfo.Name, inParameterInfo.Tooltip), inValue, inParameterInfo.Type, inParameterInfo.Default, flags, inContext.WithParameter(inParameterInfo)));
}
static private NestedValue DoNestedValueField(GUIContent inLabel, NestedValue inValue, RSTypeInfo inExpectedType, RSValue inDefaultValue, RSValidationFlags inFlags, RSValidationContext inContext)
{
EditorGUILayout.BeginVertical();
ResolvableValueMode nextType = ListGUILayout.Popup(inLabel, inValue.Mode, RSEditorUtility.GetResolvableValueModes(inExpectedType, inFlags, inContext));
RSValue value = inDefaultValue;
EntityScopedIdentifier query = new EntityScopedIdentifier(EntityScopeData.Self(), 0);
RegisterIndex register = RegisterIndex.Register0;
using (new EditorGUI.IndentLevelScope())
{
switch (inValue.Mode)
{
case ResolvableValueMode.Argument:
{
if (inContext.Trigger == null)
{
EditorGUILayout.HelpBox("No parameter available: No Trigger", MessageType.Error);
}
else if (inContext.Trigger.ParameterType == null)
{
EditorGUILayout.HelpBox(string.Format("No parameter available - Trigger {0} has no parameter", inContext.Trigger.Name), MessageType.Error);
}
else if (inExpectedType != null && !inContext.Trigger.ParameterType.Type.CanConvert(inExpectedType))
{
EditorGUILayout.HelpBox(string.Format("No parameter available - Trigger {0} has incompatible parameter type {1}, which cannot convert to {2}", inContext.Trigger.Name, inContext.Trigger.ParameterType.Type, inExpectedType), MessageType.Error);
}
break;
}
case ResolvableValueMode.Value:
{
if (inExpectedType == null || inExpectedType == RSBuiltInTypes.Any || inFlags.Has(RSValidationFlags.DisallowDirectValue))
{
EditorGUILayout.HelpBox("Cannot specify a value in this context", MessageType.Error);
}
else
{
value = RSValueField(EditorGUIUtility.TrTempContent(inExpectedType.FriendlyName), inValue.Value, inExpectedType, inFlags, inContext);
}
break;
}
case ResolvableValueMode.Query:
{
query = ValueGUILayout.QueryField(RuleGUILayout.Content.ResolvableValueQueryLabel, inValue.Query, inExpectedType, inFlags.ForMethod(false), inContext);
break;
}
case ResolvableValueMode.Register:
{
register = (RegisterIndex)EnumGUILayout.EnumField(RuleGUILayout.Content.ResolvableValueRegisterLabel, inValue.Register);
break;
}
}
}
EditorGUILayout.EndVertical();
switch (nextType)
{
case ResolvableValueMode.Argument:
return(NestedValue.FromArgument());
case ResolvableValueMode.Query:
return(NestedValue.FromQuery(query));
case ResolvableValueMode.Register:
return(NestedValue.FromRegister(register));
case ResolvableValueMode.Value:
default:
return(NestedValue.FromValue(value));
}
}
/// <summary>
/// Renders a layout editor for a NestedValue.
/// </summary>
static public NestedValue NestedValueField(GUIContent inLabel, NestedValue inValue, RSTypeInfo inExpectedType, RSValue inDefaultValue, RSValidationFlags inFlags, RSValidationContext inContext)
{
return(DoNestedValueField(inLabel, inValue, inExpectedType, inDefaultValue, inFlags, inContext));
}
static private void ValidateNestedParameter(RSParameterInfo inParameterInfo, NestedValue inValue, RSValidationState ioState, RSValidationContext inContext)
{
ioState.PushContext("Parameter: {0}", inParameterInfo.Name);
ValidateNestedValue(inValue, inParameterInfo.Type, RSValidationFlags.None.ForParameter(inParameterInfo), ioState, inContext.WithParameter(inParameterInfo));
ioState.PopContext();
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>
/// A hash code for the current <see cref="T:System.Object"/>.
/// </returns>
/// <filterpriority>2</filterpriority>
public override int GetHashCode()
{
return(NestedValue != null ? NestedValue.GetHashCode() : 0);
}
