public static bool IsState(this VariableSave variableSave, ElementSave container) { ElementSave throwaway1; StateSaveCategory throwaway2; return(variableSave.IsState(container, out throwaway1, out throwaway2)); }
private void AddAssignmentForInterpolationForVariable(ICodeBlock curBlock, VariableSave variable, ElementSave container) { string memberNameInCode = variable.MemberNameInCode(container, VariableNamesToReplaceForStates); ElementSave categoryContainer; StateSaveCategory stateSaveCategory; if (variable.IsState(container, out categoryContainer, out stateSaveCategory, recursive: false) && !string.IsNullOrEmpty(variable.SourceObject)) { string line = string.Format( "{0}.InterpolateBetween({1}FirstValue, {1}SecondValue, interpolationValue);", SaveObjectExtensionMethods.InstanceNameInCode(variable.SourceObject), memberNameInCode.Replace(".", "")); curBlock.Line(line); } else { switch (variable.Type) { case "int": curBlock.Line(string.Format("{0} = FlatRedBall.Math.MathFunctions.RoundToInt({1}FirstValue* (1 - interpolationValue) + {1}SecondValue * interpolationValue);", memberNameInCode, memberNameInCode.Replace(".", ""))); break; case "float": case "double": curBlock.Line(string.Format("{0} = {1}FirstValue * (1 - interpolationValue) + {1}SecondValue * interpolationValue;", memberNameInCode, memberNameInCode.Replace(".", ""))); break; } } }
private InterpolationCharacteristic GetInterpolationCharacteristic(VariableSave variableSave, ElementSave container) { string variableType = null; if (variableSave != null) { variableType = variableSave.Type; } if (variableSave != null && variableSave.IsState(container)) { ElementSave categoryContainer; StateSaveCategory stateSaveCategory; if (variableSave.IsState(container, out categoryContainer, out stateSaveCategory, recursive: false)) { return(InterpolationCharacteristic.CanInterpolate); } else { // it's an exposed variable which cant be interpolated currently return(InterpolationCharacteristic.CantInterpolate); } } if (variableSave == null || variableType == null || variableType == "string" || variableType == "bool" || variableType == "Color" || variableSave.IsFile ) { return(InterpolationCharacteristic.CantInterpolate); } if (variableType == "float" || variableType == "int" || variableType == "double" || variableType == "byte") { return(InterpolationCharacteristic.CanInterpolate); } return(InterpolationCharacteristic.CantInterpolate); }
public static string MemberNameInCode(this VariableSave variableSave, ElementSave container, Dictionary <string, string> replacements = null) { if (replacements == null) { replacements = StateCodeGenerator.VariableNamesToReplaceForStates; } var rootName = variableSave.GetRootName(); var objectName = variableSave.SourceObject; if (replacements.ContainsKey(rootName)) { rootName = replacements[rootName]; } else { rootName = rootName.Replace(" ", "_"); } ElementSave throwaway1; StateSaveCategory throwaway2; // recursive is false because we only want to prepend "Current" if it's not an exposed variable if (variableSave.IsState(container, out throwaway1, out throwaway2, recursive: false)) { if (rootName == "State") { rootName = "CurrentVariableState"; } else { rootName = "Current" + rootName; } } if (string.IsNullOrEmpty(objectName)) { return(rootName); } else { objectName = InstanceNameInCode(objectName); return(objectName + '.' + rootName); } }
private static void FillWithExposedVariable(VariableSave exposedVariable, ElementSave container, StringBuilder stringBuilder, int tabCount) { var type = exposedVariable.Type; if (exposedVariable.IsState(container, out ElementSave stateContainer, out StateSaveCategory category)) { var stateContainerType = GetClassNameForType(stateContainer.Name, VisualApi.Gum); type = $"{stateContainerType}.{category.Name}"; } stringBuilder.AppendLine(ToTabs(tabCount) + $"public {type} {exposedVariable.ExposedAsName}"); stringBuilder.AppendLine(ToTabs(tabCount) + "{"); tabCount++; stringBuilder.AppendLine(ToTabs(tabCount) + $"get => {exposedVariable.Name};"); stringBuilder.AppendLine(ToTabs(tabCount) + $"set => {exposedVariable.Name} = value;"); tabCount--; stringBuilder.AppendLine(ToTabs(tabCount) + "}"); }
private static string VariableValueToGumCodeValue(VariableSave variable, ElementSave container) { if (variable.Value is float asFloat) { return(asFloat.ToString(CultureInfo.InvariantCulture) + "f"); } else if (variable.Value is string asString) { if (variable.GetRootName() == "Parent") { return(asString); } else if (variable.IsState(container, out ElementSave categoryContainer, out StateSaveCategory category)) { var containerClassName = GetClassNameForType(categoryContainer.Name, VisualApi.Gum); return($"{containerClassName}.{category.Name}.{asString}"); } else { return("\"" + asString.Replace("\n", "\\n") + "\""); } }
public static TypeConverter GetTypeConverter(this VariableSave variableSave, ElementSave container = null) { ElementSave categoryContainer; StateSaveCategory category; if (variableSave.CustomTypeConverter != null) { return(variableSave.CustomTypeConverter); } else if (variableSave.IsFont) { return(new FontTypeConverter()); } else if (variableSave.Name == "Guide") { AvailableGuidesTypeConverter availableGuidesTypeConverter = new AvailableGuidesTypeConverter(); availableGuidesTypeConverter.GumProjectSave = ObjectFinder.Self.GumProjectSave; availableGuidesTypeConverter.ShowNewGuide = false; return(availableGuidesTypeConverter); } else if (variableSave.IsState(container, out categoryContainer, out category)) { string categoryName = null; if (category != null) { categoryName = category.Name; } AvailableStatesConverter converter = new AvailableStatesConverter(categoryName); converter.ElementSave = categoryContainer; return(converter); } else { // We should see if it's an exposed variable, and if so, let's look to the source object's type converters bool foundInRoot = false; if (!string.IsNullOrEmpty(variableSave.SourceObject) && container != null) { InstanceSave instance = container.GetInstance(variableSave.SourceObject); if (instance != null) { // see if the instance has a variable var foundElementSave = ObjectFinder.Self.GetRootStandardElementSave(instance); if (foundElementSave != null) { VariableSave rootVariableSave = foundElementSave.DefaultState.GetVariableSave(variableSave.GetRootName()); if (rootVariableSave != null) { return(rootVariableSave.GetTypeConverter((ElementSave)null)); } } } } } Type type = variableSave.GetRuntimeType(); return(variableSave.GetTypeConverter(type)); }
private static bool GetShouldIncludeBasedOnBaseType(VariableSave defaultVariable, ElementSave container, InstanceSave instanceSave, StandardElementSave rootElementSave) { bool shouldInclude = false; if (string.IsNullOrEmpty(defaultVariable.SourceObject)) { if (container is ScreenSave) { // If it's a Screen, then the answer is "yes" because // Screens don't have a base type that they can switch, // so any variable that's part of the Screen is always part // of the Screen. // do nothing to shouldInclude shouldInclude = true; } else { if (container is ComponentSave) { // See if it's defined in the standards list var foundInstance = StandardElementsManager.Self.GetDefaultStateFor("Component").Variables.FirstOrDefault( item => item.Name == defaultVariable.Name); shouldInclude = foundInstance != null; } // If the defaultVariable's // source object is null then // that means that the variable // is being set on "this". However, // variables that are set on "this" may // not actually be valid for the type, but // they may still exist because the object type // was switched. Therefore, we want to make sure // that the variable is valid given the type of object // that "this" currently is by checking the default state // on the rootElementSave if (!shouldInclude && rootElementSave != null) { shouldInclude = rootElementSave.DefaultState.GetVariableSave(defaultVariable.Name) != null; } string nameWithoutState = null; if (!shouldInclude && defaultVariable.Name.EndsWith("State") && instanceSave != null) { nameWithoutState = defaultVariable.Name.Substring(0, defaultVariable.Name.Length - "State".Length); var instanceElement = ObjectFinder.Self.GetElementSave(instanceSave.BaseType); // See if this is a category: if (!string.IsNullOrEmpty(nameWithoutState) && instanceElement != null && instanceElement.Categories.Any(item => item.Name == nameWithoutState)) { shouldInclude = true; } } if (!shouldInclude && instanceSave == null && defaultVariable.IsState(container)) { return(true); } } } else { shouldInclude = SelectedState.Self.SelectedInstance != null || !string.IsNullOrEmpty(defaultVariable.ExposedAsName); } return(shouldInclude); }
//private void ReactIfChangedMemberIsAnimation(ElementSave parentElement, string changedMember, object oldValue, out bool saveProject) //{ // const string sourceFileString = "SourceFile"; // if (changedMember == sourceFileString) // { // StateSave stateSave = SelectedState.Self.SelectedStateSave; // string value = (string)stateSave.GetValueRecursive(sourceFileString); // if (!FileManager.IsRelative) // { // } // saveProject = true; // } // saveProject = false; //} /// <summary> /// Called when the user clicks the "Make Default" menu item /// </summary> /// <param name="variableName">The variable to make default.</param> private void ResetVariableToDefault(StateReferencingInstanceMember srim) { string variableName = srim.Name; bool shouldReset = false; bool affectsTreeView = false; var selectedElement = SelectedState.Self.SelectedElement; if (SelectedState.Self.SelectedInstance != null) { affectsTreeView = variableName == "Parent"; //variableName = SelectedState.Self.SelectedInstance.Name + "." + variableName; shouldReset = true; } else if (selectedElement != null) { shouldReset = // Don't let the user reset standard element variables, they have to have some actual value (selectedElement is StandardElementSave) == false || // ... unless it's not the default SelectedState.Self.SelectedStateSave != SelectedState.Self.SelectedElement.DefaultState; } // now we reset, but we don't remove the variable: //if(shouldReset) //{ // // If the variable is part of a category, then we don't allow setting the variable to default - they gotta do it through the cateory itself // if (isPartOfCategory) // { // var window = new DeletingVariablesInCategoriesMessageBox(); // window.ShowDialog(); // shouldReset = false; // } //} if (shouldReset) { bool isPartOfCategory = srim.StateSaveCategory != null; StateSave state = SelectedState.Self.SelectedStateSave; bool wasChangeMade = false; VariableSave variable = state.GetVariableSave(variableName); if (variable != null) { // Don't remove the variable if it's part of an element - we still want it there // so it can be set, we just don't want it to set a value // Update August 13, 2013 // Actually, we do want to remove it if it's part of an element but not the // default state // Update October 17, 2017 // Now that components do not // necessarily need to have all // of their variables, we can remove // the variable now. In fact, we should //bool shouldRemove = SelectedState.Self.SelectedInstance != null || // SelectedState.Self.SelectedStateSave != SelectedState.Self.SelectedElement.DefaultState; // Also, don't remove it if it's an exposed variable, this un-exposes things bool shouldRemove = string.IsNullOrEmpty(variable.ExposedAsName) && !isPartOfCategory; // Update October 7, 2019 // Actually, we can remove any variable so long as the current state isn't the "base definition" for it // For elements - no variables are the base variable definitions except for variables that are categorized // state variables for categories defined in this element if (shouldRemove) { var isState = variable.IsState(selectedElement, out ElementSave categoryContainer, out StateSaveCategory categoryForVariable); if (isState) { var isDefinedHere = categoryForVariable != null && categoryContainer == selectedElement; shouldRemove = !isDefinedHere; } } if (shouldRemove) { state.Variables.Remove(variable); } else if (isPartOfCategory) { var variableInDefault = SelectedState.Self.SelectedElement.DefaultState.GetVariableSave(variable.Name); if (variableInDefault != null) { GumCommands.Self.GuiCommands.PrintOutput( $"The variable {variable.Name} is part of the category {srim.StateSaveCategory.Name} so it cannot be removed. Instead, the value has been set to the value in the default state"); variable.Value = variableInDefault.Value; } else { GumCommands.Self.GuiCommands.PrintOutput("Could not set value to default because the default state doesn't set this value"); } } else { variable.Value = null; variable.SetsValue = false; } wasChangeMade = true; // We need to refresh the property grid and the wireframe display } else { // Maybe this is a variable list? VariableListSave variableList = state.GetVariableListSave(variableName); if (variableList != null) { state.VariableLists.Remove(variableList); // We don't support this yet: // variableList.SetsValue = false; // just to be safe wasChangeMade = true; } } if (wasChangeMade) { RefreshUI(force: true); WireframeObjectManager.Self.RefreshAll(true); SelectionManager.Self.Refresh(); if (affectsTreeView) { GumCommands.Self.GuiCommands.RefreshElementTreeView(SelectedState.Self.SelectedElement); } if (ProjectManager.Self.GeneralSettingsFile.AutoSave) { ProjectManager.Self.SaveElement(SelectedState.Self.SelectedElement); } } } else { srim.IsDefault = false; } }
private void ModifyVariableTypeForProperty(ref string variableType, VariableSave variableSave, ElementSave elementSave) { if (mTypeToQualifiedTypes.ContainsKey(variableType)) { variableType = mTypeToQualifiedTypes[variableType]; } if (string.IsNullOrEmpty(variableSave.SourceObject)) { if (variableType == "State") { // Not sure why this was returning CurrentVariableState, as that is the property name, // not the property type, and here we want the property type. //variableType = elementSave.Name + "Runtime.CurrentVariableState"; //variableType = FlatRedBall.IO.FileManager.RemovePath(elementSave.Name) + "Runtime.VariableState"; // Actually we want to include the prefix for namespace: //variableType = FlatRedBall.IO.FileManager.RemovePath(elementSave.Name) + "Runtime.VariableState"; variableType = elementSave.Name.Replace('/', '.').Replace('\\', '.') + "Runtime.VariableState"; } else if (variableSave.Type.EndsWith("State")) { var typeWithoutState = variableSave.Type.Substring(0, variableSave.Type.Length - "State".Length); var foundCategory = elementSave.Categories.FirstOrDefault(item => item.Name == typeWithoutState); if (foundCategory != null) { // categorized state enums are nullable variableType = $"{elementSave.Name.Replace('/', '.').Replace('\\', '.')}Runtime.{foundCategory.Name}?"; } } else if (variableSave.IsState(elementSave)) { var foundCategory = elementSave.Categories.FirstOrDefault(item => item.Name == variableSave.Type); if (foundCategory != null) { // categorized state enums are nullable variableType = $"{elementSave.Name.Replace('/', '.').Replace('\\', '.')}Runtime.{foundCategory.Name}?"; } } } else if (variableSave.IsFile) { variableType = "Microsoft.Xna.Framework.Graphics.Texture2D"; } else { var instance = elementSave.Instances.FirstOrDefault(item => item.Name == variableSave.SourceObject); if (instance != null) { var element = ObjectFinder.Self.GetElementSave(instance); if (element != null) { var rootName = variableSave.GetRootName(); var variableInInstanceElement = element.DefaultState.Variables.FirstOrDefault(item => item.Name == rootName || item.ExposedAsName == rootName); if (variableInInstanceElement != null) { ModifyVariableTypeForProperty(ref variableType, variableInInstanceElement, element); } } } } }