/// <summary> /// A query selector for a unknown entity. /// </summary> static public int QuerySelectorUnknown(Rect inPosition, int inCurrentId, RSTypeInfo inReturnType, bool inbNoParams, RSLibrary inLibrary) { RSEditorUtility.s_QueryElements.Clear(); inLibrary.GetAllLocalQueries(RSEditorUtility.s_QueryElements, inReturnType, inbNoParams); return(RSGUI.RSElementSelector(inPosition, inCurrentId, RSEditorUtility.s_QueryElements)); }
/// <summary> /// A query selector for a specific entity. /// </summary> static public int QuerySelector(int inCurrentId, IRSEntity inEntity, RSTypeInfo inReturnType, bool inbNoParams, RSLibrary inLibrary) { RSEditorUtility.s_QueryElements.Clear(); inLibrary.GetAllQueriesForEntity(inEntity, RSEditorUtility.s_QueryElements, inReturnType, inbNoParams); return(RSGUILayout.RSElementSelector(inCurrentId, RSEditorUtility.s_QueryElements)); }
static private void ValidateCondition(RSConditionData inCondition, RSValidationState ioState, RSValidationContext inContext) { ioState.PushContext("Query"); ValidateResolvableValue(inCondition.Query, null, RSValidationFlags.None.ForConditionQuery(), ioState, inContext); ioState.PopContext(); RSTypeInfo expectedType = inCondition.Query.TypeInfo(inContext.Trigger, inContext.Library); if (inCondition.Query.Mode != ResolvableValueMode.Value && expectedType != null) { ioState.PushContext("Operator"); CompareOperator op = inCondition.Operator; if (!expectedType.IsOperatorAllowed(op)) { ioState.Error("Operator {0} is not allowed for type {1}", op, expectedType); } ioState.PopContext(); if (op.IsBinary()) { ioState.PushContext("Target"); ValidateResolvableValue(inCondition.Target, expectedType, RSValidationFlags.None.ForConditionTarget(), ioState, inContext); ioState.PopContext(); } } }
/// <summary> /// A query selector for the global scope. /// </summary> static public int QuerySelectorGlobal(GUIContent inLabel, int inCurrentId, RSTypeInfo inReturnType, bool inbNoParams, RSLibrary inLibrary) { RSEditorUtility.s_QueryElements.Clear(); inLibrary.GetAllGlobalQueries(RSEditorUtility.s_QueryElements, inReturnType, inbNoParams); return(RSGUILayout.RSElementSelector(inLabel, inCurrentId, RSEditorUtility.s_QueryElements)); }
/// <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)); } }
static private void ValidateValue(RSValue inValue, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationState ioState, RSValidationContext inContext) { Type systemType = inExpectedType.SystemType; if (systemType.IsEnum) { try { Enum currentValue = inValue.AsEnum(); } catch (Exception e) { Debug.LogException(e); ioState.Error("Enum {0} cannot be represented as type {1}", inValue, inExpectedType); } return; } if (inExpectedType == RSBuiltInTypes.Entity) { EntityScopeData scope = inValue.AsEntity; ValidateEntityScope(scope, inFlags.ForEntityValue(), ioState, inContext); } else if (inExpectedType == RSBuiltInTypes.GroupId) { RSGroupId group = inValue.AsGroupId; ValidateGroupId(group, inFlags, ioState, inContext); } else if (inExpectedType == RSBuiltInTypes.TriggerId) { RSTriggerId triggerId = inValue.AsTriggerId; ValidateTriggerId(triggerId, inFlags, ioState, inContext); } }
/// <summary> /// A trigger selector. /// </summary> static public RSTriggerId TriggerSelector(RSTriggerId inCurrentId, RSTypeInfo inParameterType, RSLibrary inLibrary) { RSEditorUtility.s_TriggerElements.Clear(); inLibrary.GetAllTriggers(RSEditorUtility.s_TriggerElements, inParameterType ?? RSBuiltInTypes.Void); int trigger = RSGUILayout.RSElementSelector((int)inCurrentId, RSEditorUtility.s_TriggerElements); return(new RSTriggerId(trigger)); }
static private RSTriggerInfo ValidateTriggerId(RSTriggerId inTriggerId, RSValidationFlags inFlags, RSValidationState ioState, RSValidationContext inContext) { RSTypeInfo restrictTriggerType = inContext.Parameter?.TriggerParameterType; if (inTriggerId == RSTriggerId.Null) { if (restrictTriggerType != null) { ioState.Error("Null trigger id provided - require trigger with parameter type {0}", restrictTriggerType); } else { ioState.Warn("Null trigger provided"); } return(null); } else { RSTriggerInfo triggerInfo = inContext.Library.GetTrigger(inTriggerId); if (triggerInfo == null) { ioState.Error("Trigger {0} does not exist", inTriggerId); } else { if (restrictTriggerType != null) { if (restrictTriggerType == RSBuiltInTypes.Void) { if (triggerInfo.ParameterType != null) { ioState.Error("Trigger with no parameter required, but trigger {0} with parameter {1} provided", triggerInfo.Name, triggerInfo.ParameterType.Type); } } else { if (triggerInfo.ParameterType == null) { ioState.Error("Trigger with parameter {0} required, but trigger {1} with no parameter provided", restrictTriggerType, triggerInfo.Name); } else if (!restrictTriggerType.CanConvert(triggerInfo.ParameterType.Type)) { ioState.Error("Trigger with parameter {0} required, but trigger {1} with incompatible parameter {2} provided", restrictTriggerType, triggerInfo.Name, triggerInfo.ParameterType.Type); } } } } return(triggerInfo); } }
static private void ValidateTriggerArgument(RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationState ioState, RSValidationContext inContext) { if (inContext.Trigger == null) { ioState.Error("Cannot use trigger parameter - no trigger"); } else if (inContext.Trigger.ParameterType == null) { ioState.Error("Cannot use trigger parameter - trigger {0} has no parameter", inContext.Trigger.Name); } else if (inExpectedType != null && !inContext.Trigger.ParameterType.Type.CanConvert(inExpectedType)) { ioState.Error("Cannot use trigger parameter - trigger {0} has incompatible parameter type {1}, which cannot convert to {2}", inContext.Trigger.Name, inContext.Trigger.ParameterType.Type, inExpectedType); } }
static internal NamedItemList <ResolvableValueMode> GetResolvableValueModes(RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationContext inContext) { bool bDisallowDirectValue = (inExpectedType == null || inExpectedType == RSBuiltInTypes.Any || inFlags.Has(RSValidationFlags.DisallowDirectValue)); bool bDisallowRegister = inFlags.Has(RSValidationFlags.DisallowRegisters); if (bDisallowDirectValue) { if (bDisallowDirectValue) { return(s_ResolvableValueModesNoValueOrRegister); } return(s_ResolvableValueModesNoRegister); } if (bDisallowRegister) { return(s_ResolvableValueModesNoRegister); } return(s_ResolvableValueModes); }
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; } } }
static private EntityScopedIdentifier DoQueryField(GUIContent inLabel, EntityScopedIdentifier inIdentifier, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationContext inContext) { EntityScopeData scope = inIdentifier.Scope; int queryId = inIdentifier.Id; bool bNoParams = inFlags.Has(RSValidationFlags.DisallowParameters); using (new EditorGUILayout.VerticalScope()) { scope = EntityScopeField(inLabel, scope, inFlags.ForMethodScope(), inContext); using (new EditorGUI.IndentLevelScope()) { switch (scope.Type) { case EntityScopeType.Global: queryId = LibraryGUILayout.QuerySelectorGlobal(Content.QueryIdLabel, queryId, inExpectedType, bNoParams, inContext.Library); break; case EntityScopeType.Null: EditorGUILayout.HelpBox("Cannot perform query on null entity", MessageType.Error); break; case EntityScopeType.Invalid: EditorGUILayout.HelpBox("Cannot perform query on missing entity", MessageType.Error); break; case EntityScopeType.Self: { if (inFlags.Has(RSValidationFlags.FilterSelection) && !scope.HasLinks() && inContext.Entity != null) { queryId = LibraryGUILayout.QuerySelector(Content.QueryIdLabel, queryId, inContext.Entity, inExpectedType, bNoParams, inContext.Library); } else { queryId = LibraryGUILayout.QuerySelectorUnknown(Content.QueryIdLabel, queryId, inExpectedType, bNoParams, 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) { queryId = LibraryGUILayout.QuerySelector(Content.QueryIdLabel, queryId, entity, inExpectedType, bNoParams, inContext.Library); } else { queryId = LibraryGUILayout.QuerySelectorUnknown(Content.QueryIdLabel, queryId, inExpectedType, bNoParams, inContext.Library); } break; } default: queryId = LibraryGUILayout.QuerySelectorUnknown(Content.QueryIdLabel, queryId, inExpectedType, bNoParams, inContext.Library); break; } if (queryId == 0) { EditorGUILayout.HelpBox("Cannot perform null query", MessageType.Error); } } } return(new EntityScopedIdentifier(scope, queryId)); }
/// <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)); } }
/// <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)); } }
/// <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 ValidateResolvableValue(RSResolvableValueData 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.Value: { if (bDisallowDirectValue) { ioState.Error("Cannot specify a direct value in this context"); } else { ValidateValue(inValue.Value, 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.Query: { ioState.PushContext("Query Id"); RSQueryInfo queryInfo = ValidateQueryId(inValue.Query, inExpectedType, inFlags.ForMethod(true), ioState, inContext); ioState.PopContext(); ioState.PushContext("Arguments"); if (queryInfo != null) { int argCount = queryInfo.Parameters.Length; if (argCount <= 0) { if (inValue.QueryArguments != null && inValue.QueryArguments.Length > 0) { ioState.Error("Arguments provided for action {0} but none required", queryInfo.Name); } } else { if (inValue.QueryArguments == null) { ioState.Error("No arguments provided for action {0} but {1} required", queryInfo.Name, argCount); } else if (inValue.QueryArguments.Length != argCount) { ioState.Error("Argument count mismatch for action {0} - {1} required but {2} provided", queryInfo.Name, argCount, inValue.QueryArguments.Length); } else { for (int i = 0; i < argCount; ++i) { ValidateNestedParameter(queryInfo.Parameters[i], inValue.QueryArguments[i], ioState, inContext); } } } } ioState.PopContext(); break; } } }
/// <summary> /// Renders a layout editor for a ResolvableValue. /// </summary> static public void ResolvableValueData(UndoTarget inUndo, GUIContent inLabel, RSResolvableValueData ioValue, RSTypeInfo inExpectedType, RSValue inDefaultValue, RSValidationFlags inFlags, RSValidationContext inContext) { DoResolvableValueData(inUndo, inLabel, ioValue, inExpectedType, inDefaultValue, 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); } }
static private RSValue DoRSValueField(GUIContent inLabel, RSValue inValue, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationContext inContext) { Type systemType = inExpectedType.SystemType; if (systemType.IsEnum) { Enum currentValue; try { currentValue = inValue.AsEnum(); } catch (Exception e) { Debug.LogException(e); currentValue = inExpectedType.DefaultValue.AsEnum(); } Enum nextValue = EnumGUILayout.EnumField(inLabel, currentValue); return(RSValue.FromEnum(nextValue)); } if (inExpectedType == RSBuiltInTypes.Int) { int currentValue = inValue.AsInt; int nextValue = EditorGUILayout.DelayedIntField(inLabel, currentValue); return(RSValue.FromInt(nextValue)); } else if (inExpectedType == RSBuiltInTypes.Float) { float currentValue = inValue.AsFloat; float nextValue = EditorGUILayout.DelayedFloatField(inLabel, currentValue); return(RSValue.FromFloat(nextValue)); } else if (inExpectedType == RSBuiltInTypes.Bool) { bool currentValue = inValue.AsBool; bool nextValue = EditorGUILayout.Toggle(inLabel, currentValue); return(RSValue.FromBool(nextValue)); } else if (inExpectedType == RSBuiltInTypes.Color) { Color currentValue = inValue.AsColor; Color nextValue = EditorGUILayout.ColorField(inLabel, currentValue); return(RSValue.FromColor(nextValue)); } else if (inExpectedType == RSBuiltInTypes.String) { string currentValue = inValue.AsString; string nextValue = EditorGUILayout.TextField(inLabel, currentValue); return(RSValue.FromString(nextValue)); } else if (inExpectedType == RSBuiltInTypes.Vector2) { Vector2 currentValue = inValue.AsVector2; Vector2 nextValue = EditorGUILayout.Vector2Field(inLabel, currentValue); return(RSValue.FromVector2(nextValue)); } else if (inExpectedType == RSBuiltInTypes.Vector3) { Vector3 currentValue = inValue.AsVector3; Vector3 nextValue = EditorGUILayout.Vector3Field(inLabel, currentValue); return(RSValue.FromVector3(nextValue)); } else if (inExpectedType == RSBuiltInTypes.Vector4) { Vector4 currentValue = inValue.AsVector4; Vector4 nextValue = EditorGUILayout.Vector4Field(inLabel, currentValue); return(RSValue.FromVector4(nextValue)); } else if (inExpectedType == RSBuiltInTypes.Entity) { EntityScopeData currentValue = inValue.AsEntity; EntityScopeData nextValue = EntityScopeField(inLabel, currentValue, inFlags.ForEntityValue(), inContext); return(RSValue.FromEntity(nextValue)); } else if (inExpectedType == RSBuiltInTypes.GroupId) { RSGroupId currentValue = inValue.AsGroupId; RSGroupId nextValue = LibraryGUILayout.GroupSelector(inLabel, currentValue, inContext.Library); return(RSValue.FromGroupId(nextValue)); } else if (inExpectedType == RSBuiltInTypes.TriggerId) { RSTriggerId currentValue = inValue.AsTriggerId; RSTypeInfo restrictTriggerType = inContext.Parameter?.TriggerParameterType; RSTriggerId nextValue; if (restrictTriggerType != null) { nextValue = LibraryGUILayout.TriggerSelector(inLabel, currentValue, restrictTriggerType, inContext.Library); } else { nextValue = LibraryGUILayout.TriggerSelector(inLabel, currentValue, inContext.Library); } return(RSValue.FromTriggerId(nextValue)); } else { EditorGUILayout.HelpBox(string.Format("Unable to display editor for type {0}", inExpectedType), MessageType.Error); } return(inValue); }
/// <summary> /// Renders editor for condition info. /// </summary> static public void ConditionData(UndoTarget inUndo, RSConditionData ioCondition, RSValidationFlags inFlags, RSValidationContext inContext) { string preview = ioCondition.GetPreviewString(inContext.Trigger, inContext.Library); GUILayout.Label(preview, RSGUIStyles.RuleHeaderStyle); EditorGUILayout.Space(); // Enabled bool bEnabled = EditorGUILayout.Toggle(Content.ConditionEnabledLabel, ioCondition.Enabled); if (bEnabled != ioCondition.Enabled) { inUndo.MarkDirty("Changed Condition Enabled"); ioCondition.Enabled = bEnabled; } EditorGUILayout.Space(); using (new EditorGUI.DisabledGroupScope(!bEnabled)) { RSTypeInfo prevQueryType = ioCondition.Query.TypeInfo(inContext.Trigger, inContext.Library); // Query ResolvableValueData(inUndo, Content.ConditionValueLabel, ioCondition.Query, null, inFlags.ForConditionQuery(), inContext); // comparison RSTypeInfo queryTypeInfo = ioCondition.Query.TypeInfo(inContext.Trigger, inContext.Library); if (ioCondition.Query.Mode != ResolvableValueMode.Value && queryTypeInfo != null) { EditorGUILayout.Space(); RSEditorUtility.s_ComparisonOperators.Clear(); foreach (var comparison in queryTypeInfo.AllowedOperators()) { RSEditorUtility.s_ComparisonOperators.Add(comparison, comparison.Name(), (int)comparison); } CompareOperator nextOperator = ioCondition.Operator; if (!RSEditorUtility.s_ComparisonOperators.Contains(nextOperator)) { nextOperator = RSEditorUtility.s_ComparisonOperators.Get(0); } nextOperator = ListGUILayout.Popup(Content.ConditionComparisonLabel, nextOperator, RSEditorUtility.s_ComparisonOperators); if (nextOperator != ioCondition.Operator) { inUndo.MarkDirty("Changed Condition Operator"); ioCondition.Operator = nextOperator; } if (nextOperator.IsBinary()) { EditorGUILayout.Space(); if (prevQueryType != queryTypeInfo) { inUndo.MarkDirty("Changed Condition Query Type"); RSResolvableValueData.SetAsValue(ref ioCondition.Target, queryTypeInfo.DefaultValue); } ResolvableValueData(inUndo, Content.ConditionTargetLabel, ioCondition.Target, queryTypeInfo, inFlags.ForConditionTarget(), inContext); } else { if (ioCondition.Target != null) { inUndo.MarkDirty("Removed Condition Comparison Target"); ioCondition.Target = null; } } if (ioCondition.Query.IsMultiValue()) { EditorGUILayout.Space(); Subset subset = (Subset)EditorGUILayout.EnumPopup(Content.ConditionSubsetLabel, ioCondition.MultiQuerySubset); if (subset != ioCondition.MultiQuerySubset) { inUndo.MarkDirty("Changed Condition MultiQuerySubset"); ioCondition.MultiQuerySubset = subset; } } } } }
/// <summary> /// A trigger selector for a specific entity. /// </summary> static public RSTriggerId TriggerSelector(Rect inPosition, RSTriggerId inCurrentId, IRSEntity inEntity, RSTypeInfo inParameterType, RSLibrary inLibrary) { RSEditorUtility.s_TriggerElements.Clear(); inLibrary.GetAllTriggersForEntity(inEntity, RSEditorUtility.s_TriggerElements, inParameterType ?? RSBuiltInTypes.Void); inLibrary.GetAllGlobalTriggers(RSEditorUtility.s_TriggerElements, inParameterType ?? RSBuiltInTypes.Void); int trigger = RSGUI.RSElementSelector(inPosition, (int)inCurrentId, RSEditorUtility.s_TriggerElements); return(new RSTriggerId(trigger)); }
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 an RSValue. /// </summary> static public RSValue RSValueField(GUIContent inLabel, RSValue inValue, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationContext inContext) { return(DoRSValueField(inLabel, inValue, inExpectedType, inFlags, inContext)); }