private static void FillWithCurrentState(ElementSave element, StringBuilder stringBuilder, int tabCount)
{
foreach (var category in element.Categories)
{
stringBuilder.AppendLine();
string enumName = category.Name;
stringBuilder.AppendLine(ToTabs(tabCount) + $"{category.Name} m{category.Name}State;");
stringBuilder.AppendLine(ToTabs(tabCount) + $"public {category.Name} {category.Name}State");
stringBuilder.AppendLine(ToTabs(tabCount) + "{");
tabCount++;
stringBuilder.AppendLine(ToTabs(tabCount) + $"get => m{category.Name}State;");
stringBuilder.AppendLine(ToTabs(tabCount) + $"set");
stringBuilder.AppendLine(ToTabs(tabCount) + "{");
tabCount++;
stringBuilder.AppendLine(ToTabs(tabCount) + $"m{category.Name}State = value;");
stringBuilder.AppendLine(ToTabs(tabCount) + $"switch (value)");
stringBuilder.AppendLine(ToTabs(tabCount) + "{");
tabCount++;
foreach (var state in category.States)
{
stringBuilder.AppendLine(ToTabs(tabCount) + $"case {category.Name}.{state.Name}:");
tabCount++;
FillWithVariablesInState(element, state, stringBuilder, tabCount);
stringBuilder.AppendLine(ToTabs(tabCount) + $"break;");
tabCount--;
}
tabCount--;
stringBuilder.AppendLine(ToTabs(tabCount) + "}");
tabCount--;
stringBuilder.AppendLine(ToTabs(tabCount) + "}");
tabCount--;
stringBuilder.AppendLine(ToTabs(tabCount) + "}");
}
}
private void HandleInstanceRenamed(ElementSave container, InstanceSave instance, string oldName)
{
var elementsInheritingFromContainer =
ObjectFinder.Self.GetElementsInheritingFrom(container);
foreach (var inheritingElement in elementsInheritingFromContainer)
{
var toRename = inheritingElement.GetInstance(oldName);
if (toRename != null)
{
toRename.Name = instance.Name;
GumCommands.Self.FileCommands.TryAutoSaveElement(inheritingElement);
GumCommands.Self.GuiCommands.RefreshElementTreeView(inheritingElement);
}
}
}
private static void HandleInstanceVariableBaseTypeSet(ElementSave container, InstanceSave instance)
{
var elementsInheritingFromContainer =
ObjectFinder.Self.GetElementsInheritingFrom(container);
foreach (var inheritingElement in elementsInheritingFromContainer)
{
var toChange = inheritingElement.GetInstance(instance.Name);
if (toChange != null)
{
toChange.BaseType = instance.BaseType;
GumCommands.Self.FileCommands.TryAutoSaveElement(inheritingElement);
}
}
}
private static void AddTreeNodeForElement(ElementSave element, TreeNode parentNode, int defaultImageIndex)
{
TreeNode treeNode = new TreeNode();
if (element.IsSourceFileMissing)
{
treeNode.ImageIndex = ExclamationIndex;
}
else
{
treeNode.ImageIndex = defaultImageIndex;
}
treeNode.Tag = element;
parentNode.Nodes.Add(treeNode);
}
private void ReactIfChangedMemberIsParent(ElementSave parentElement, InstanceSave instance, string changedMember, object oldValue)
{
bool isValidAssignment = true;
VariableSave variable = SelectedState.Self.SelectedVariableSave;
// Eventually need to handle tunneled variables
if (variable != null && changedMember == "Parent")
{
if ((variable.Value as string) == "<NONE>")
{
variable.Value = null;
}
if (variable.Value != null)
{
var newParent = parentElement.Instances.FirstOrDefault(item => item.Name == variable.Value as string);
var newValue = variable.Value;
// unset it before finding recursive children, in case there is a circular reference:
variable.Value = null;
var childrenInstances = GetRecursiveChildrenOf(parentElement, instance);
if (childrenInstances.Contains(newParent))
{
// uh oh, circular referenced detected, don't allow it!
MessageBox.Show("This parent assignment would produce a circular reference, which is not allowed.");
variable.Value = oldValue;
isValidAssignment = false;
}
else
{
// set it back:
variable.Value = newValue;
}
}
if (isValidAssignment)
{
GumCommands.Self.GuiCommands.RefreshElementTreeView(parentElement);
}
else
{
GumCommands.Self.GuiCommands.RefreshPropertyGrid(force: true);
}
}
}
private void GetMemberCategoriesForStateCategory(ElementSave element, InstanceSave instance, List <MemberCategory> categories, StateSaveCategory stateCategory)
{
categories.Clear();
List <string> commonMembers = new List <string>();
var firstState = stateCategory.States.FirstOrDefault();
if (firstState != null)
{
foreach (var variable in firstState.Variables)
{
bool canAdd = variable.ExcludeFromInstances == false || instance == null;
if (canAdd)
{
commonMembers.Add(variable.Name);
}
}
}
if (commonMembers.Any())
{
var memberCategory = new MemberCategory();
memberCategory.Name = $"{stateCategory.Name} Variables";
categories.Add(memberCategory);
foreach (var commonMember in commonMembers)
{
var instanceMember = new InstanceMember();
instanceMember.Name = commonMember;
instanceMember.CustomGetTypeEvent += (member) => typeof(string);
instanceMember.CustomGetEvent += (member) => commonMember;
instanceMember.CustomSetEvent += (not, used) =>
{
VariableInCategoryPropagationLogic.Self
.AskRemoveVariableFromAllStatesInCategory(commonMember, stateCategory);
};
instanceMember.PreferredDisplayer = typeof(VariableRemoveButton);
memberCategory.Members.Add(instanceMember);
}
}
}
private ICodeBlock GenerateClassHeader(ICodeBlock codeBlock, ElementSave elementSave)
{
string runtimeClassName = GetUnqualifiedRuntimeTypeFor(elementSave);
string inheritance = "Gum.Wireframe.GraphicalUiElement";
if (elementSave.BaseType != "Component" && !string.IsNullOrEmpty(elementSave.BaseType))
{
inheritance = GueRuntimeNamespace + "." + elementSave.BaseType + "Runtime";
}
var asComponentSave = elementSave as ComponentSave;
if (asComponentSave != null)
{
var project = AppState.Self.GumProjectSave;
var behaviors = project.Behaviors;
foreach (var behaviorReference in asComponentSave.Behaviors)
{
inheritance += $", {GueRuntimeNamespace}.I{behaviorReference.BehaviorName}";
var behavior = behaviors.FirstOrDefault(item => item.Name == behaviorReference.BehaviorName);
string behaviorInheritance = null;
if (behavior != null)
{
behaviorInheritance = BehaviorCodeGenerator.GetInterfacesFromBehaviors(behavior);
}
if (!string.IsNullOrEmpty(behaviorInheritance))
{
inheritance += $", {behaviorInheritance}";
}
}
}
// If it's not public then exposing an instance in a public class makes the project not compile
//ICodeBlock currentBlock = codeBlock.Class("partial", runtimeClassName, " : " + inheritance);
ICodeBlock currentBlock = codeBlock.Class("public partial", runtimeClassName, " : " + inheritance);
return(currentBlock);
}
// Discussion about Selection
// Selection is a rather complicated
// system in Gum because tree nodes can
// be selected in a number of ways:
// 1. The user can push/release (click)
// 2. The user can select an item in the
// wireframe window which in turn selects
// the appropriate tree node.
// 3. The user pushes on a tree node, but then
// drags off of it to do a drag+drop somewhere
// else.
// We want the app to refresh what it is displaying
// in scenario 1 and 2, but not in 3. Therefore the
// MultiSelectTreeView class has an event called AfterClickSelect
// which only fires when the user actually clicks on an item (1) so
// that #3 doesn't fire off an event. However, this means that #2 will
// no longer fire off the event either. We need to then make sure that #2
// does still fire off an event, so we'll do this by manually raising the event
// in the Select methods where a Save object is selected.
public void Select(InstanceSave instanceSave, ElementSave parent)
{
if (instanceSave != null)
{
TreeNode parentTreeNode = GetTreeNodeFor(parent);
// This could be null if the user started a new project or loaded a different project.
if (parentTreeNode != null)
{
Select(GetTreeNodeFor(instanceSave, parentTreeNode));
}
}
else
{
Select((TreeNode)null);
}
}
public static VariableSave GetVariableRecursive(this StateSave stateSave, string variableName)
{
VariableSave variableSave = stateSave.GetVariableSave(variableName);
if (variableSave == null)
{
// Is this thing the default?
ElementSave parent = stateSave.ParentContainer;
if (parent != null && stateSave != parent.DefaultState)
{
variableSave = stateSave.GetVariableSave(variableName);
if (variableSave == null)
{
variableSave = parent.DefaultState.GetVariableSave(variableName);
}
}
if (variableSave == null && parent != null)
{
ElementSave baseElement = GetBaseElementFromVariable(variableName, parent);
if (baseElement != null)
{
string nameInBase = variableName;
if (variableName.Contains('.'))
{
// this variable is set on an instance, but we're going into the
// base type, so we want to get the raw variable and not the variable
// as tied to an instance.
nameInBase = variableName.Substring(nameInBase.IndexOf('.') + 1);
}
return(baseElement.DefaultState.GetVariableRecursive(nameInBase));
}
}
return(variableSave);
}
else
{
return(variableSave);
}
}
private bool TryHandleCustomGetter(VariableSave variable, ElementSave elementSave, ICodeBlock getter)
{
if (variable.GetRootName() == "SourceFile" && elementSave.Name == "NineSlice")
{
getter.Line("return ContainedNineSlice.TopLeftTexture;");
return(true);
}
// handle colors:
if (elementSave.Name == "Circle" || elementSave.Name == "Rectangle")
{
string containedObject;
if (elementSave.Name == "Circle")
{
containedObject = "ContainedCircle";
}
else
{
containedObject = "ContainedRectangle";
}
if (variable.Name == "Alpha")
{
getter.Line($"return {containedObject}.Color.A;");
return(true);
}
else if (variable.Name == "Red")
{
getter.Line($"return {containedObject}.Color.R;");
return(true);
}
else if (variable.Name == "Green")
{
getter.Line($"return {containedObject}.Color.G;");
return(true);
}
else if (variable.Name == "Blue")
{
getter.Line($"return {containedObject}.Color.B;");
return(true);
}
}
return(false);
}
private static void PastedCopiedState()
{
ElementSave container = SelectedState.Self.SelectedElement;
var targetCategory = SelectedState.Self.SelectedStateCategorySave;
/////////////////////Early Out//////////////////
if (container == null)
{
return;
}
//////////////////End Early Out////////////////
StateSave newStateSave = mCopiedState.Clone();
newStateSave.Variables.RemoveAll(item => item.CanOnlyBeSetInDefaultState);
newStateSave.ParentContainer = container;
string name = mCopiedState.Name + "Copy";
if (targetCategory != null)
{
name = StringFunctions.MakeStringUnique(name, targetCategory.States.Select(item => item.Name));
newStateSave.Name = name;
targetCategory.States.Add(newStateSave);
}
else
{
name = StringFunctions.MakeStringUnique(name, container.States.Select(item => item.Name));
newStateSave.Name = name;
container.States.Add(newStateSave);
}
StateTreeViewManager.Self.RefreshUI(container);
//SelectedState.Self.SelectedInstance = targetInstance;
SelectedState.Self.SelectedStateSave = newStateSave;
GumCommands.Self.FileCommands.TryAutoSaveElement(container);
}
private void HandleDroppedElementSave(object draggedComponentOrElement, TreeNode treeNodeDroppedOn, object targetTag)
{
ElementSave draggedAsElementSave = draggedComponentOrElement as ElementSave;
// User dragged an element save - so they want to take something like a
// text object and make an instance in another element like a Screen
bool handled;
if (targetTag is ElementSave)
{
HandleDroppedElementInElement(draggedAsElementSave, targetTag as ElementSave, out handled);
}
else if (targetTag is InstanceSave)
{
// The user dropped it on an instance save, but he likely meant to drop
// it as an object under the current element.
InstanceSave targetInstance = targetTag as InstanceSave;
var newInstance = HandleDroppedElementInElement(draggedAsElementSave, targetInstance.ParentContainer, out handled);
if (newInstance != null)
{
// Since the user dropped on another instance, let's try to parent it:
HandleDroppingInstanceOnTarget(targetInstance, newInstance, targetInstance.ParentContainer);
}
}
else if (treeNodeDroppedOn.IsTopComponentContainerTreeNode())
{
HandleDroppedElementOnTopComponentTreeNode(draggedAsElementSave, out handled);
}
else if (draggedAsElementSave is ComponentSave && treeNodeDroppedOn.IsPartOfComponentsFolderStructure())
{
HandleDroppedElementOnFolder(draggedAsElementSave, treeNodeDroppedOn, out handled);
}
else if (draggedAsElementSave is ScreenSave && treeNodeDroppedOn.IsPartOfScreensFolderStructure())
{
HandleDroppedElementOnFolder(draggedAsElementSave, treeNodeDroppedOn, out handled);
}
else
{
MessageBox.Show("You must drop " + draggedAsElementSave.Name + " on either a Screen or an Component");
}
}
static StateSave GetStateFromCategorizedName(string categorizedName, ElementSave element)
{
if (categorizedName.Contains("/"))
{
var names = categorizedName.Split('/');
string category = names[0];
string stateName = names[1];
return(element
.Categories.FirstOrDefault(item => item.Name == category)
?.States.FirstOrDefault(item => item.Name == stateName));
}
else
{
return(element.States.FirstOrDefault(item => item.Name == categorizedName));
}
}
void OnMoveBackward(object sender, EventArgs e)
{
InstanceSave instance = SelectedState.Self.SelectedInstance;
ElementSave element = SelectedState.Self.SelectedElement;
if (instance != null)
{
int index = element.Instances.IndexOf(instance);
if (index != 0)
{
element.Instances.RemoveAt(index);
element.Instances.Insert(index - 1, instance);
RefreshInResponseToReorder();
}
}
}
private void GenerateStateInterpolateBetween(ElementSave elementSave, ICodeBlock currentBlock)
{
currentBlock.Line("#region State Interpolation");
string enumType = "VariableState";
IEnumerable <StateSave> states = elementSave.States;
GenerateInterpolateBetween(elementSave, currentBlock, enumType, states);
foreach (var category in elementSave.Categories)
{
enumType = category.Name;
states = category.States;
GenerateInterpolateBetween(elementSave, currentBlock, enumType, states);
}
currentBlock.Line("#endregion");
}
public GraphicalUiElement GetRepresentation(ElementSave elementSave)
{
#if DEBUG
if (elementSave == null)
{
throw new NullReferenceException("The argument elementSave is null");
}
#endif
foreach (GraphicalUiElement ipso in AllIpsos)
{
if (ipso.Tag == elementSave)
{
return(ipso);
}
}
return(null);
}
private void GenerateCurrentStateFields(ElementSave elementSave, ICodeBlock currentBlock)
{
currentBlock.Line("#region State Fields");
string propertyName = "CurrentVariableState";
string propertyType = "VariableState";
currentBlock.Line(propertyType + " m" + propertyName + ";");
foreach (var category in elementSave.Categories)
{
propertyName = "Current" + category.Name + "State";
propertyType = category.Name;
currentBlock.Line(propertyType + " m" + propertyName + ";");
}
currentBlock.Line("#endregion");
}
private void FillListWithReferencedFiles(List <string> files, ElementSave element)
{
RecursiveVariableFinder rvf;
string value;
foreach (var state in element.AllStates)
{
rvf = new RecursiveVariableFinder(element.DefaultState);
value = rvf.GetValue <string>("SourceFile");
if (!string.IsNullOrEmpty(value))
{
files.Add(value);
}
value = rvf.GetValue <string>("CustomFontFile");
if (!string.IsNullOrEmpty(value))
{
files.Add(value);
}
List <Gum.Wireframe.ElementWithState> elementStack = new List <Wireframe.ElementWithState>();
var elementWithState = new Gum.Wireframe.ElementWithState(element);
elementWithState.StateName = state.Name;
elementStack.Add(elementWithState);
foreach (InstanceSave instance in element.Instances)
{
rvf = new RecursiveVariableFinder(instance, elementStack);
value = rvf.GetValue <string>("SourceFile");
if (!string.IsNullOrEmpty(value))
{
files.Add(value);
}
value = rvf.GetValue <string>("CustomFontFile");
if (!string.IsNullOrEmpty(value))
{
files.Add(value);
}
}
}
}
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 bool TryAskForRemovalConfirmation(StateSave stateSave, ElementSave elementSave)
{
bool shouldContinue = true;
// See if the element is used anywhere
List <InstanceSave> foundInstances = new List <InstanceSave>();
ObjectFinder.Self.GetElementsReferencing(elementSave, null, foundInstances);
foreach (var instance in foundInstances)
{
// We don't want to go recursively, just top level because
// I *think* that the lists will include copies of the instances
// recursively
ElementSave parent = instance.ParentContainer;
string variableToLookFor = instance.Name + ".State";
// loop through all of the states to see if any of the parents' states
// reference the state that is being removed.
foreach (var stateInContainer in parent.AllStates)
{
var foundVariable = stateInContainer.Variables.FirstOrDefault(item => item.Name == variableToLookFor);
if (foundVariable != null && foundVariable.Value == stateSave.Name)
{
MultiButtonMessageBox mbmb = new MultiButtonMessageBox();
mbmb.MessageText = "The state " + stateSave.Name + " is used in the element " +
elementSave + " in its state " + stateInContainer + ".\n What would you like to do?";
mbmb.AddButton("Do nothing - project may be in an invalid state", System.Windows.Forms.DialogResult.No);
mbmb.AddButton("Change variable to default", System.Windows.Forms.DialogResult.OK);
// eventually will want to add a cancel option
if (mbmb.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
foundVariable.Value = "Default";
}
}
}
}
return(shouldContinue);
}
public static GraphicalUiElement ToGraphicalUiElement(this InstanceSave instanceSave, SystemManagers systemManagers)
{
#if DEBUG
if (ObjectFinder.Self.GumProjectSave == null)
{
throw new InvalidOperationException("You need to set the ObjectFinder's GumProjectSave first so it can track references");
}
#endif
ElementSave instanceElement = ObjectFinder.Self.GetElementSave(instanceSave.BaseType);
GraphicalUiElement toReturn = null;
if (instanceElement != null)
{
toReturn = ElementSaveExtensions.CreateGueForElement(instanceElement, true);
// If we get here but there's no contained graphical object then that means we don't
// have a strongly-typed system (like when a game is running in FRB). Therefore, we'll
// just fall back to the regular creation of graphical objects, like is done in the Gum tool:
if (toReturn.RenderableComponent == null)
{
instanceElement.SetGraphicalUiElement(toReturn, systemManagers);
}
toReturn.Name = instanceSave.Name;
toReturn.Tag = instanceSave;
var state = instanceSave.ParentContainer.DefaultState;
foreach (var variable in state.Variables.Where(item => item.SetsValue && item.SourceObject == instanceSave.Name))
{
string propertyOnInstance = variable.Name.Substring(variable.Name.LastIndexOf('.') + 1);
if (toReturn.IsExposedVariable(propertyOnInstance))
{
toReturn.SetProperty(propertyOnInstance, variable.Value);
}
}
}
return(toReturn);
}
public string GetCustomCodeTemplateCode(ElementSave element)
{
// Example:
/*
* using System;
* using System.Collections.Generic;
* using System.Linq;
*
* namespace DesktopGlForms.GumRuntimes.DefaultForms
* {
* public partial class ButtonRuntime
* {
* partial void CustomInitialize()
* {
*
* }
* }
* }
*
*/
var codeBlockBase = new CodeBlockBaseNoIndent(null);
ICodeBlock codeBlock = codeBlockBase;
var toReturn = codeBlock;
codeBlock.Line("using System;");
codeBlock.Line("using System.Collections.Generic;");
codeBlock.Line("using System.Linq;");
codeBlock.Line();
codeBlock = codeBlock.Namespace(
GueDerivingClassCodeGenerator.Self.GetFullRuntimeNamespaceFor(element));
{
string runtimeClassName =
GueDerivingClassCodeGenerator.Self.GetUnqualifiedRuntimeTypeFor(element);
codeBlock = codeBlock.Class("public partial", runtimeClassName);
{
codeBlock = codeBlock.Function("partial void", "CustomInitialize");
}
}
return(toReturn.ToString());
}
private void GenerateAssignReferencesMethod(ElementSave elementSave, ICodeBlock currentBlock)
{
currentBlock = currentBlock.Function("public override void", "AssignReferences", "");
{
currentBlock.Line("base.AssignReferences();");
foreach (var instance in elementSave.Instances)
{
var foundBase = Gum.Managers.ObjectFinder.Self.GetElementSave(instance.BaseType);
if (foundBase != null)
{
currentBlock.Line(instance.MemberNameInCode() +
" = this.GetGraphicalUiElementByName(\"" + instance.MemberNameInCode() + "\") as " +
GueDerivingClassCodeGenerator.GetQualifiedRuntimeTypeFor(instance) + ";");
ElementSave baseElement = Gum.Managers.ObjectFinder.Self.GetElementSave(instance.BaseType);
if (baseElement != null && (baseElement is StandardElementSave) == false)
{
currentBlock.Line(instance.MemberNameInCode() + ".AssignReferences();");
}
foreach (var eventSave in elementSave.Events.Where(item =>
item.GetSourceObject() == instance.Name && !string.IsNullOrEmpty(item.ExposedAsName)))
{
currentBlock.Line(eventSave.Name + " += Raise" + eventSave.ExposedAsName + ";");
}
}
}
List <EventSave> exposedChildrenEvents = EventCodeGenerator.Self.GetExposedChildrenEvents(elementSave);
foreach (var exposedChildEvent in exposedChildrenEvents)
{
currentBlock.Line($"{exposedChildEvent.Name} += (unused) => {exposedChildEvent.ExposedAsName}?.Invoke(this);");
}
// must be done after instances are assigned, since beahvior code may reference instances
GenerateStandardFrbBehaviorCode(elementSave, currentBlock);
currentBlock.Line("CallCustomInitialize();");
}
}
private ICodeBlock AssignValuesUsingStartingValues(ElementSave element, ICodeBlock curBlock, Dictionary <VariableSave, InterpolationCharacteristic> mInterpolationCharacteristics)
{
foreach (KeyValuePair <VariableSave, InterpolationCharacteristic> kvp in mInterpolationCharacteristics)
{
var variable = kvp.Key;
if (kvp.Value != InterpolationCharacteristic.CantInterpolate)
{
string stringSuffix = variable.MemberNameInCode(element, VariableNamesToReplaceForStates).Replace(".", "");
curBlock = curBlock.If("set" + stringSuffix + FirstValue + " && set" + stringSuffix + SecondValue);
AddAssignmentForInterpolationForVariable(curBlock, variable, element);
curBlock = curBlock.End();
}
}
return(curBlock);
}
private void GenerateCurrentStateFields(ElementSave elementSave, ICodeBlock currentBlock)
{
currentBlock.Line("#region State Fields");
string propertyName = "CurrentVariableState";
string propertyType = "VariableState";
currentBlock.Line(propertyType + " m" + propertyName + ";");
foreach (var category in elementSave.Categories)
{
propertyName = "Current" + category.Name + "State";
propertyType = category.Name;
// Make these nullable because categorized states may not be set at all
currentBlock.Line($"{propertyType}? m{propertyName};");
}
currentBlock.Line("#endregion");
}
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 void RefreshErrors(ElementSave element)
{
var asComponent = element as ComponentSave;
if (asComponent != null)
{
var behaviors = ProjectState.Self.GumProjectSave.Behaviors;
var behaviorReferences = asComponent.Behaviors;
string message = null;
foreach (var behaviorReference in behaviorReferences)
{
var foundBehavior = behaviors.FirstOrDefault(item => item.Name == behaviorReference.BehaviorName);
if (foundBehavior != null)
{
var requiredVariables = foundBehavior.RequiredVariables.Variables;
foreach (var requiredVariable in requiredVariables)
{
bool existsInComponent = asComponent.DefaultState.Variables
.Any(item =>
(item.Name == requiredVariable.Name || item.ExposedAsName == requiredVariable.Name) &&
item.Type == requiredVariable.Type);
if (!existsInComponent)
{
message += $"Variable {requiredVariable.Name} of type {requiredVariable.Type} is required.\n";
}
}
}
}
bool showError = !string.IsNullOrEmpty(message);
this.variableViewModel.HasErrors = showError ?
System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
this.variableViewModel.ErrorInformation = message;
}
}
private PropertyDescriptorCollection DisplayCurrentInstance(PropertyDescriptorCollection pdc, InstanceSave instanceSave)
{
ElementSave elementSave = instanceSave.GetBaseElementSave();
StateSave stateToDisplay;
if (elementSave != null)
{
stateToDisplay = elementSave.States[0];
}
else
{
stateToDisplay = new StateSave();
}
pdc = DisplayCurrentElement(pdc, elementSave, instanceSave, stateToDisplay, instanceSave.Name, AmountToDisplay.ElementAndExposedOnly);
return(pdc);
}
private void RefreshElementTreeNode(TreeNode node, ElementSave elementSave)
{
List <InstanceSave> expandedInstances = new List <InstanceSave>();
List <InstanceSave> allInstances = elementSave.Instances;
foreach (InstanceSave instance in allInstances)
{
var treeNode = GetTreeNodeFor(instance, node);
if (treeNode?.Nodes.Count > 0 && treeNode?.IsExpanded == true)
{
expandedInstances.Add(instance);
}
}
node.Text = FileManager.RemovePath(elementSave.Name);
node.Nodes.Clear();
foreach (InstanceSave instance in allInstances)
{
TreeNode nodeForInstance = GetTreeNodeFor(instance, node);
if (nodeForInstance == null)
{
nodeForInstance = AddTreeNodeForInstance(instance, node);
}
if (expandedInstances.Contains(instance))
{
nodeForInstance.Expand();
}
var siblingInstances = instance.GetSiblingsIncludingThis();
var desiredIndex = siblingInstances.IndexOf(instance);
var nodeParent = nodeForInstance.Parent;
if (desiredIndex != nodeParent.Nodes.IndexOf(nodeForInstance))
{
nodeParent.Nodes.Remove(nodeForInstance);
nodeParent.Nodes.Insert(desiredIndex, nodeForInstance);
}
}
}
private string GetElementPrefix(ElementSave element)
{
if (element is ScreenSave)
{
return(ElementReference.ScreenSubfolder + "/");
}
else if (element is ComponentSave)
{
return(ElementReference.ComponentSubfolder + "/");
}
else if (element is StandardElementSave)
{
return(ElementReference.StandardSubfolder + "/");
}
else
{
return(null);
}
}
