/// <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> /// Renders editor for rule info. Does not include conditions or actions. /// </summary> static public void RuleData(UndoTarget inUndo, RSRuleData ioRule, RSRuleTableData ioTable, RSValidationFlags inFlags, RSValidationContext inContext) { string preview = ioRule.GetPreviewString(null, inContext.Library); GUILayout.Label(preview, RSGUIStyles.RuleHeaderStyle); EditorGUILayout.Space(); string newName = EditorGUILayout.TextField(Content.RuleNameLabel, ioRule.Name); if (newName != ioRule.Name) { inUndo.MarkDirty("Changed Rule Name"); ioRule.Name = newName; } RSTriggerId newTriggerId; if (inFlags.Has(RSValidationFlags.FilterSelection) && inContext.Entity != null) { newTriggerId = LibraryGUILayout.TriggerSelector(Content.RuleTriggerLabel, ioRule.TriggerId, inContext.Entity, inContext.Library); } else { newTriggerId = LibraryGUILayout.TriggerSelector(Content.RuleTriggerLabel, ioRule.TriggerId, inContext.Library); } if (newTriggerId != ioRule.TriggerId) { inUndo.MarkDirty("Changed Rule Trigger", true); ioRule.TriggerId = newTriggerId; TableUtils.UpdateUniqueRuleTriggers(ioTable); } if (newTriggerId != RSTriggerId.Null) { RSTriggerInfo info = inContext.Library.GetTrigger(newTriggerId); if (info != null && info.ParameterType != null) { using (new EditorGUI.IndentLevelScope()) { EditorGUILayout.LabelField(Content.RuleParameterLabel, EditorGUIUtility.TrTextContent(info.ParameterType.ToStringWithoutDefault(), info.ParameterType.Tooltip)); } } } EditorGUILayout.Space(); // Enabled bool bEnabled = EditorGUILayout.Toggle(Content.RuleEnabledLabel, ioRule.Enabled); if (bEnabled != ioRule.Enabled) { inUndo.MarkDirty("Changed Rule Enabled"); ioRule.Enabled = bEnabled; } bool bOnlyOnce = EditorGUILayout.Toggle(Content.RuleOnlyOnceLabel, ioRule.OnlyOnce); if (bOnlyOnce != ioRule.OnlyOnce) { inUndo.MarkDirty("Changed Rule OnlyOnce"); ioRule.OnlyOnce = bOnlyOnce; } bool bDontInterrupt = EditorGUILayout.Toggle(Content.RuleDontInterruptLabel, ioRule.DontInterrupt); if (bDontInterrupt != ioRule.DontInterrupt) { inUndo.MarkDirty("Changed Rule DontInterrupt"); ioRule.DontInterrupt = bDontInterrupt; } EditorGUILayout.Space(); string newGroup = EditorGUILayout.TextField(Content.RuleGroupLabel, ioRule.RoutineGroup); if (newGroup != ioRule.RoutineGroup) { inUndo.MarkDirty("Changed Rule Group"); ioRule.RoutineGroup = newGroup; } }
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 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; } } } } }
private void SearchGUI() { { RootMode nextMode = (RootMode)EnumGUILayout.EnumField("Mode", m_Params.RootMode); if (nextMode != m_Params.RootMode) { m_SelfUndoTarget.MarkDirty("Switched mode"); m_Params.RootMode = nextMode; m_SearchQueued = true; } } EditorGUILayout.Space(); switch (m_Params.RootMode) { case RootMode.Entity: EntityParamsGUI(); break; case RootMode.Table: TableParamsGUI(); break; } GUILayout.FlexibleSpace(); if (Event.current.isKey && Event.current.keyCode == KeyCode.F5) { m_SearchQueued = true; } if (GUILayout.Button("Perform Search (F5)")) { m_SearchQueued = true; } }