/// <summary>
/// Renders a layout editor for a scoped action identifier.
/// </summary>
static public EntityScopedIdentifier ActionField(EntityScopedIdentifier inIdentifier, RSValidationFlags inFlags, RSValidationContext inContext)
{
using (new RSGUI.LabelWidthScope(0))
{
return(DoActionField(GUIContent.none, inIdentifier, inFlags, inContext));
}
}
/// <summary>
/// Renders a layout editor for a scoped query identifier.
/// </summary>
static public EntityScopedIdentifier QueryField(EntityScopedIdentifier inIdentifier, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationContext inContext)
{
using (new RSGUI.LabelWidthScope(0))
{
return(DoQueryField(GUIContent.none, inIdentifier, inExpectedType, inFlags, inContext));
}
}
static private RSQueryInfo ValidateQueryId(EntityScopedIdentifier inIdentifier, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationState ioState, RSValidationContext inContext)
{
bool bNoParams = inFlags.Has(RSValidationFlags.DisallowParameters);
ValidateEntityScope(inIdentifier.Scope, inFlags.ForMethodScope(), ioState, inContext);
if (inIdentifier.Id == 0)
{
ioState.Error("Null query not allowed");
return(null);
}
else
{
RSQueryInfo queryInfo = inContext.Library.GetQuery(inIdentifier.Id);
if (queryInfo == null)
{
ioState.Error("Query {0} does not exist", inIdentifier.Id);
}
else
{
if (inExpectedType != null && !queryInfo.ReturnType.CanConvert(inExpectedType))
{
ioState.Error("Query {0} returns incompatible type {1}, which cannot convert to desired type {2}", queryInfo.Name, queryInfo.ReturnType, inExpectedType);
}
if (bNoParams && queryInfo.Parameters != null && queryInfo.Parameters.Length > 0)
{
ioState.Error("Query {0} has parameters, which is not allowed in this context", queryInfo.Name);
}
switch (inIdentifier.Scope.Type)
{
case EntityScopeType.Global:
{
if (queryInfo.OwnerType != null)
{
ioState.Error("Query {0} is bound to type {1} but was specified as a global query", queryInfo.Name, queryInfo.OwnerType.Name);
}
break;
}
case EntityScopeType.Null:
case EntityScopeType.Invalid:
break;
default:
{
if (queryInfo.OwnerType == null)
{
ioState.Error("Query {0} is bound to global scope but was specified as a local query", queryInfo.Name);
}
break;
}
}
}
return(queryInfo);
}
}
/// <summary>
/// Renders editor for Action info.
/// </summary>
static public void ActionData(UndoTarget inUndo, RSActionData ioAction, RSValidationFlags inFlags, RSValidationContext inContext)
{
string preview = ioAction.GetPreviewString(inContext.Trigger, inContext.Library);
GUILayout.Label(preview, RSGUIStyles.RuleHeaderStyle);
EditorGUILayout.Space();
// Enabled
bool bEnabled = EditorGUILayout.Toggle("Enabled", ioAction.Enabled);
if (bEnabled != ioAction.Enabled)
{
inUndo.MarkDirty("Changed Action Enabled");
ioAction.Enabled = bEnabled;
}
EditorGUILayout.Space();
using (new EditorGUI.DisabledGroupScope(!bEnabled))
{
EntityScopedIdentifier action = ValueGUILayout.ActionField(EditorGUIUtility.TrTempContent("Action"), ioAction.Action, inFlags, inContext);
RSActionInfo actionInfo = inContext.Library.GetAction(action.Id);
if (action != ioAction.Action)
{
bool bChangedId = ioAction.Action.Id != action.Id;
inUndo.MarkDirty("Changed Action", true);
ioAction.Action = action;
if (bChangedId)
{
if (actionInfo != null)
{
actionInfo.PopulateDefaultArguments(ioAction);
}
else
{
ioAction.Arguments = null;
}
}
}
if (actionInfo != null && ioAction.Arguments != null && ioAction.Arguments.Length > 0)
{
EditorGUILayout.Space();
EditorGUILayout.LabelField("Arguments", RSGUIStyles.SubHeaderStyle);
for (int i = 0; i < ioAction.Arguments.Length; ++i)
{
ParameterData(inUndo, actionInfo.Parameters[i], ioAction.Arguments[i], inFlags, inContext);
}
}
}
}
/// <summary>
/// Resolves a query to a set of values.
/// </summary>
public MultiReturn <RSValue> EvaluateQuery(EntityScopedIdentifier inQuery, NestedValue[] inArguments)
{
RSQueryInfo queryInfo = m_Environment.Library.GetQuery(inQuery.Id);
MultiReturn <IRSRuntimeEntity> targets = ResolveEntity(inQuery.Scope);
ResolveArgsArray(inArguments, queryInfo.TempArgStorage);
if (targets.Set != null)
{
return(new MultiReturn <RSValue>(m_Environment.EvaluateQueries(targets.Set, queryInfo, queryInfo.TempArgStorage, this)));
}
return(new MultiReturn <RSValue>(m_Environment.EvaluateQuery(targets.Single, queryInfo, queryInfo.TempArgStorage, this)));
}
static private RSActionInfo ValidateActionId(EntityScopedIdentifier inIdentifier, RSValidationFlags inFlags, RSValidationState ioState, RSValidationContext inContext)
{
ValidateEntityScope(inIdentifier.Scope, inFlags.ForMethodScope(), ioState, inContext);
if (inIdentifier.Id == 0)
{
ioState.Error("Null action not allowed");
return(null);
}
else
{
RSActionInfo actionInfo = inContext.Library.GetAction(inIdentifier.Id);
if (actionInfo == null)
{
ioState.Error("Action {0} does not exist", inIdentifier.Id);
}
else
{
switch (inIdentifier.Scope.Type)
{
case EntityScopeType.Global:
{
if (actionInfo.OwnerType != null)
{
ioState.Error("Action {0} is bound to type {1} but was specified as a global action", actionInfo.Name, actionInfo.OwnerType.Name);
}
break;
}
case EntityScopeType.Null:
case EntityScopeType.Invalid:
break;
default:
{
if (actionInfo.OwnerType == null)
{
ioState.Error("Action {0} is bound to global scope but was specified as a local action", actionInfo.Name);
}
break;
}
}
}
return(actionInfo);
}
}
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();
}
static private EntityScopedIdentifier DoActionField(GUIContent inLabel, EntityScopedIdentifier inIdentifier, RSValidationFlags inFlags, RSValidationContext inContext)
{
EntityScopeData scope = inIdentifier.Scope;
int actionId = inIdentifier.Id;
using (new EditorGUILayout.VerticalScope())
{
scope = EntityScopeField(inLabel, scope, inFlags.ForMethodScope(), inContext);
using (new EditorGUI.IndentLevelScope())
{
switch (scope.Type)
{
case EntityScopeType.Global:
actionId = LibraryGUILayout.ActionSelectorGlobal(Content.ActionIdLabel, actionId, inContext.Library);
break;
case EntityScopeType.Null:
EditorGUILayout.HelpBox("Cannot perform action on null entity", MessageType.Error);
break;
case EntityScopeType.Invalid:
EditorGUILayout.HelpBox("Cannot perform action on missing entity", MessageType.Error);
break;
case EntityScopeType.Self:
{
if (inFlags.Has(RSValidationFlags.FilterSelection) && !scope.HasLinks() && inContext.Entity != null)
{
actionId = LibraryGUILayout.ActionSelector(Content.ActionIdLabel, actionId, inContext.Entity, inContext.Library);
}
else
{
actionId = LibraryGUILayout.ActionSelectorUnknown(Content.ActionIdLabel, actionId, inContext.Library);
}
break;
}
case EntityScopeType.ObjectById:
{
RSEntityId entityId = scope.IdArg;
IRSEntity entity = null;
if (inFlags.Has(RSValidationFlags.FilterSelection) && entityId != RSEntityId.Null && !scope.HasLinks() && inContext.Manager != null && (entity = inContext.Manager.Lookup.EntityWithId(entityId)) != null)
{
actionId = LibraryGUILayout.ActionSelector(Content.ActionIdLabel, actionId, entity, inContext.Library);
}
else
{
actionId = LibraryGUILayout.ActionSelectorUnknown(Content.ActionIdLabel, actionId, inContext.Library);
}
break;
}
default:
actionId = LibraryGUILayout.ActionSelectorUnknown(Content.ActionIdLabel, actionId, inContext.Library);
break;
}
if (actionId == 0)
{
EditorGUILayout.HelpBox("Cannot perform null action", MessageType.Error);
}
}
}
return(new EntityScopedIdentifier(scope, actionId));
}
/// <summary>
/// Renders a layout editor for a scoped action identifier.
/// </summary>
static public EntityScopedIdentifier ActionField(GUIContent inLabel, EntityScopedIdentifier inIdentifier, RSValidationFlags inFlags, RSValidationContext inContext)
{
return(DoActionField(inLabel, inIdentifier, inFlags, inContext));
}
/// <summary>
/// Renders a layout editor for a scoped query identifier.
/// </summary>
static public EntityScopedIdentifier QueryField(GUIContent inLabel, EntityScopedIdentifier inIdentifier, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationContext inContext)
{
return(DoQueryField(inLabel, inIdentifier, inExpectedType, inFlags, inContext));
}
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));
}
}
