internal void SetVariable(ElementSave gumElement, GumInstance gumInstance, string variableName, object oldValue, bool save = true)
{
var glueProject = GluePluginState.Self.GlueProject;
///////////////////////Early Out///////////////////////
if (glueProject == null || GluePluginState.Self.InitializationState != InitializationState.Initialized)
{
return;
}
////////////////////End Early Out/////////////////////
var shouldApplyValue = GetIfShouldApplyValue(gumElement, gumInstance, variableName);
if (shouldApplyValue)
{
ApplyChangedVariable(gumElement, gumInstance, variableName, glueProject, save);
}
else
{
var currentState = SelectedState.Self.SelectedStateSave;
currentState.SetValue($"{gumInstance.Name}.{variableName}", oldValue, "string");
}
}
public static object GetCurrentValueForVariable(string baseVariableName, InstanceSave instanceSave)
{
string throwaway;
object currentValueAsObject;
GetCurrentValueForVariable(baseVariableName, instanceSave, out throwaway, out currentValueAsObject);
return currentValueAsObject;
}
private void CreateTextInScreen()
{
mTextInScreen = new InstanceSave();
mTextInScreen.Name = mElements.Button.Instances[0].Name;
mTextInScreen.BaseType = "Text";
mElements.Screen.Instances.Add(mTextInScreen);
}
public static List<string> GetAvailableStates(InstanceSave instanceSave, string categoryName)
{
ElementSave elementSave = ObjectFinder.Self.GetElementSave(instanceSave.BaseType);
List<string> toReturn = GetAvailableStates(elementSave, categoryName);
return toReturn;
}
public bool IsInstanceNameValid(string instanceName, InstanceSave instanceSave, ElementSave elementSave, out string whyNotValid)
{
IsNameValidCommon(instanceName, out whyNotValid);
if (string.IsNullOrEmpty(whyNotValid))
{
IsNameAlreadyUsed(instanceName, instanceSave, elementSave, out whyNotValid);
}
return string.IsNullOrEmpty(whyNotValid);
}
public StateReferencingInstanceMember(InstanceSavePropertyDescriptor ispd, StateSave stateSave,
string variableName, InstanceSave instanceSave, ElementSave elementSave)
: base(variableName, stateSave)
{
mInstanceSave = instanceSave;
mStateSave = stateSave;
mVariableName = variableName;
mPropertyDescriptor = ispd;
mElementSave = elementSave;
this.CustomGetEvent += GetEvent;
this.CustomSetEvent += SetEvent;
this.CustomGetTypeEvent += GetTypeEvent;
this.SortValue = int.MaxValue;
if (instanceSave != null)
{
this.Instance = instanceSave;
}
else
{
this.Instance = elementSave;
}
DisplayName = RootVariableName;
TryAddExposeVariableMenuOptions(instanceSave);
// This could be slow since we have to check it for every variable in an object.
// Maybe we'll want to pass this in to the function?
StandardElementSave standardElement = null;
if (instanceSave != null)
{
standardElement = ObjectFinder.Self.GetRootStandardElementSave(instanceSave);
}
else
{
standardElement = ObjectFinder.Self.GetRootStandardElementSave(elementSave);
}
VariableSave standardVariable = null;
if (standardElement != null)
{
standardVariable = standardElement.DefaultState.Variables.FirstOrDefault(item => item.Name == RootVariableName);
}
if (standardVariable != null)
{
this.SortValue = standardVariable.DesiredOrder;
}
}
private bool GetIfShouldApplyValue(ElementSave gumElement, GumInstance gumInstance, string variableName)
{
var shouldApply = true;
if (variableName == "Parent" && gumInstance != null)
{
var currentState = SelectedState.Self.SelectedStateSave;
var newParentName = currentState.GetValueOrDefault <string>($"{gumInstance.Name}.Parent");
GumInstance newGumParent = null;
var glueElement = GluePluginObjectFinder.Self.GetGlueElementFrom(gumElement);
var glueInstance = glueElement?.AllNamedObjects.FirstOrDefault(item => item.InstanceName == gumInstance.Name);
FlatRedBall.Glue.SaveClasses.NamedObjectSave newGlueInstanceParent = null;
if (!string.IsNullOrEmpty(newParentName))
{
newGumParent = gumElement.GetInstance(newParentName);
newGlueInstanceParent =
glueElement?.AllNamedObjects.FirstOrDefault(item => item.FieldName == newParentName);
}
if (newGumParent != null)
{
if (newGlueInstanceParent?.SourceType == FlatRedBall.Glue.SaveClasses.SourceType.FlatRedBallType &&
newGlueInstanceParent.SourceClassType == "ShapeCollection")
{
var canBeParent = glueInstance?.SourceType == FlatRedBall.Glue.SaveClasses.SourceType.FlatRedBallType &&
(
glueInstance.SourceClassType == "Circle" ||
glueInstance.SourceClassType == "FlatRedBall.Math.Geometry.Circle" ||
glueInstance.SourceClassType == "AxisAlignedRectangle" ||
glueInstance.SourceClassType == "FlatRedBall.Math.Geometry.AxisAlignedRectangle" ||
glueInstance.SourceClassType == "Polygon" ||
glueInstance.SourceClassType == "FlatRedBall.Math.Geometry.Polygon"
);
shouldApply = canBeParent;
}
else
{
var canNewParentBeParent = newGumParent.BaseType == "Container";
shouldApply = canNewParentBeParent;
}
}
}
return(shouldApply);
}
public InstanceSave AddInstance(ElementSave elementToAddTo, string name)
{
if (elementToAddTo == null)
{
throw new Exception("Could not add instance named " + name + " because no element is selected");
}
InstanceSave instanceSave = new InstanceSave();
instanceSave.Name = name;
instanceSave.ParentContainer = elementToAddTo;
instanceSave.BaseType = StandardElementsManager.Self.DefaultType;
elementToAddTo.Instances.Add(instanceSave);
return instanceSave;
}
private NamedObjectSave CreateNosFor(InstanceSave instance, IElement container)
{
NamedObjectSave nos = new NamedObjectSave();
string name = instance.Name;
// See if this name is already used by RFS's
var allRfss = container.GetAllReferencedFileSavesRecursively();
while (allRfss.Any(item => item.GetInstanceName() == name) || container.ReferencedFiles.Any(item => item.Name == name))
{
name = name + instance.BaseType;
}
nos.InstanceName = name;
RecursiveVariableFinder rvf = new RecursiveVariableFinder(instance, instance.ParentContainer);
if (instance.BaseType == "Sprite")
{
nos.SourceType = SourceType.FlatRedBallType;
nos.SourceClassType = "Sprite";
float width = rvf.GetValue<float>("Width");
float height = rvf.GetValue<float>("Height");
if (width == 0 && height == 0)
{
nos.SetPropertyValue("TextureScale", 1.0f);
}
else
{
// Eventually handle width/height
nos.SetPropertyValue("Width", width);
nos.SetPropertyValue("Height", height);
}
SetPositionValuesOn(nos, instance);
string texture = rvf.GetValue<string>("SourceFile");
string fileInstanceName = FileManager.RemoveExtension(FileManager.RemovePath(texture));
var added = nos.SetPropertyValue("Texture", fileInstanceName);
added.Type = "Texture2D";
}
return nos;
}
public EventInstanceMember(ElementSave element, InstanceSave instance, EventSave eventSave)
{
mElementSave = element;
mEventSave = eventSave;
if (!string.IsNullOrEmpty(eventSave.ExposedAsName))
{
this.Name = eventSave.ExposedAsName;
}
else
{
this.Name = eventSave.Name;
}
if (instance != null)
{
this.DisplayName = eventSave.GetRootName();
}
this.CustomSetEvent += HandlePropertyChanged;
this.CustomGetEvent += HandlePropertyGet;
this.CustomGetTypeEvent += HandleGetType;
}
private static void ApplyChangedVariable(ElementSave gumElement, GumInstance gumInstance, string variableName, FlatRedBall.Glue.SaveClasses.GlueProjectSave glueProject, bool save)
{
var glueElement = GluePluginObjectFinder.Self.GetGlueElementFrom(gumElement);
/////////////////// early out
if (glueElement == null)
{
return;
}
///////////////endn early out
var fullVariableName = variableName;
FlatRedBall.Glue.SaveClasses.NamedObjectSave foundNos = null;
if (gumInstance != null)
{
fullVariableName = $"{gumInstance.Name}.{variableName}";
foundNos = glueElement.AllNamedObjects
.FirstOrDefault(item => item.InstanceName == gumInstance.Name);
}
var gumValue = gumElement.GetValueFromThisOrBase(fullVariableName);
if (foundNos != null)
{
var handled = TryHandleAssigningMultipleVariables(gumElement, gumInstance, variableName, glueElement, foundNos, gumValue);
if (!handled)
{
HandleIndividualVariableAssignment(gumElement, gumInstance, variableName, glueElement, foundNos, gumValue);
}
}
if (save)
{
FileManager.XmlSerialize(glueProject, GluePluginState.Self.GlueProjectFilePath.StandardizedCaseSensitive);
}
}
private static void HandleIndividualVariableAssignment(ElementSave gumElement, GumInstance gumInstance, string variableName, GlueElement glueElement, FlatRedBall.Glue.SaveClasses.NamedObjectSave foundNos, object gumValue)
{
var gumToGlueConverter = GumToGlueConverter.Self;
var glueVariableName = gumToGlueConverter.ConvertVariableName(variableName, gumInstance);
var glueValue = gumToGlueConverter
.ConvertVariableValue(variableName, gumValue, gumInstance);
var type = gumToGlueConverter.ConvertType(variableName, gumValue, gumInstance);
var handled = gumToGlueConverter.ApplyGumVariableCustom(gumInstance, gumElement, glueVariableName, glueValue);
if (!handled)
{
var selectedGumState = SelectedState.Self.SelectedStateSave;
if (selectedGumState == SelectedState.Self.SelectedElement?.DefaultState)
{
var glueVariable = foundNos.SetVariableValue(glueVariableName, glueValue);
glueVariable.Type = type;
}
else
{
GlueState glueState;
glueState = GetOrCreateGlueState(glueElement, selectedGumState);
if (gumInstance != null)
{
// The only way Glue states can set this value is to have a tunneled variable, so we gotta look for that
var tunneledVariable = glueElement.CustomVariables
.FirstOrDefault(item => item.SourceObject == gumInstance.Name && item.SourceObjectProperty == glueVariableName);
if (tunneledVariable == null)
{
tunneledVariable = new FlatRedBall.Glue.SaveClasses.CustomVariable();
tunneledVariable.Name = gumInstance.Name + glueVariableName;
tunneledVariable.DefaultValue = null;
tunneledVariable.SourceObject = gumInstance.Name;
tunneledVariable.SourceObjectProperty = glueVariableName;
tunneledVariable.Type = type;
glueElement.CustomVariables.Add(tunneledVariable);
}
var stateVariable = glueState.InstructionSaves.FirstOrDefault(item => item.Member == tunneledVariable.Name);
if (stateVariable == null)
{
stateVariable = new FlatRedBall.Content.Instructions.InstructionSave();
stateVariable.Member = tunneledVariable.Name;
glueState.InstructionSaves.Add(stateVariable);
}
stateVariable.Value = glueValue;
}
else
{
var stateVariable = glueState.InstructionSaves.FirstOrDefault(item => item.Member == glueVariableName);
if (stateVariable == null)
{
stateVariable = new FlatRedBall.Content.Instructions.InstructionSave();
stateVariable.Member = glueVariableName;
glueState.InstructionSaves.Add(stateVariable);
}
stateVariable.Value = glueValue;
}
}
}
}
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 VariableSave TryGetVariableFromStatesOnInstance(InstanceSave instance, string variable, ElementSave instanceBase, IEnumerable<StateSave> statesToPullFrom)
{
string stateVariableName;
StateSave fallbackState;
List<StateSave> statesToLoopThrough;
VariableSave foundVariableSave = null;
foreach (var stateCategory in instanceBase.Categories)
{
stateVariableName = stateCategory.Name + "State";
fallbackState = null;
statesToLoopThrough = stateCategory.States;
foundVariableSave = TryGetVariableFromStateOnInstance(instance, variable, statesToPullFrom,
stateVariableName, fallbackState, statesToLoopThrough);
}
if (foundVariableSave == null)
{
stateVariableName = "State";
fallbackState = instanceBase.DefaultState;
statesToLoopThrough = instanceBase.States;
foundVariableSave = TryGetVariableFromStateOnInstance(instance, variable, statesToPullFrom,
stateVariableName, fallbackState, statesToLoopThrough);
}
return foundVariableSave;
}
private static VariableSave TryGetVariableFromStateOnInstance(InstanceSave instance, string variable, IEnumerable<StateSave> statesToPullFrom, string stateVariableName, StateSave fallbackState, List<StateSave> statesToLoopThrough)
{
VariableSave foundVariableSave = null;
// Let's see if this is in a non-default state
string thisState = null;
foreach (var stateToPullFrom in statesToPullFrom)
{
var foundStateVariable = stateToPullFrom.GetVariableSave(instance.Name + "." + stateVariableName);
if (foundStateVariable != null && foundStateVariable.SetsValue)
{
thisState = foundStateVariable.Value as string;
}
}
StateSave instanceStateToPullFrom = fallbackState;
// if thisState is not null, then the state is being explicitly set, so let's try to get that state
if (!string.IsNullOrEmpty(thisState) && statesToLoopThrough.Any(item => item.Name == thisState))
{
instanceStateToPullFrom = statesToLoopThrough.First(item => item.Name == thisState);
}
if (instanceStateToPullFrom != null)
{
// Eventually use the instanceBase's current state value
foundVariableSave = instanceStateToPullFrom.GetVariableRecursive(variable);
}
return foundVariableSave;
}
public static void Initialize(this InstanceSave instanceSave)
{
// nothing to do currently?
}
private static void GetStatesToUse(InstanceSave instance, List<ElementWithState> elementStack, bool forceDefault, ElementSave instanceBase, RecursiveVariableFinder rvf, out List<StateSave> statesToPullFrom, out StateSave defaultState)
{
statesToPullFrom = null;
defaultState = null;
#if GUM
if (SelectedState.Self.SelectedElement != null)
{
statesToPullFrom = new List<StateSave> { SelectedState.Self.SelectedElement.DefaultState };
defaultState = SelectedState.Self.SelectedElement.DefaultState;
}
#endif
if (elementStack.Count != 0)
{
if (elementStack.Last().Element == null)
{
throw new InvalidOperationException("The ElementStack contains an ElementWithState with no Element");
}
statesToPullFrom = elementStack.Last().AllStates.ToList();
defaultState = elementStack.Last().Element.DefaultState;
}
#if GUM
if (elementStack.Count != 0 && elementStack.Last().Element == SelectedState.Self.SelectedElement &&
SelectedState.Self.SelectedStateSave != null &&
!forceDefault)
{
statesToPullFrom = new List<StateSave> { SelectedState.Self.SelectedStateSave };
}
#endif
}
internal void InstanceSelected(ElementSave elementSave, InstanceSave instance)
{
CallMethodOnPlugin(
delegate(PluginBase plugin)
{
plugin.CallInstanceSelected(elementSave, instance);
},
"InstanceSelected"
);
}
public static bool IsComponent(this InstanceSave instanceSave)
{
ComponentSave baseAsComponentSave = ObjectFinder.Self.GetComponent(instanceSave.BaseType);
return(baseAsComponentSave != null);
}
public static VariableSave GetVariableFromThisOrBase(this InstanceSave instance,
List <ElementWithState> elementStack, string variable)
{
return(GetVariableFromThisOrBase(instance, elementStack, new RecursiveVariableFinder(instance, elementStack), variable, false, false));
}
private static bool TryHandleAssigningMultipleVariables(ElementSave gumElement, GumInstance gumInstance, string variableName, GlueElement glueElement, FlatRedBall.Glue.SaveClasses.NamedObjectSave foundNos, object gumValue)
{
var isTextureValue = variableName == "Texture Address" ||
variableName == "Texture Left" ||
variableName == "Texture Top" ||
variableName == "Texture Width" ||
variableName == "Texture Height";
var handled = false;
if (isTextureValue)
{
string variablePrefix = null;
if (gumInstance != null)
{
variablePrefix = $"{gumInstance.Name}.";
}
var state = SelectedState.Self.SelectedStateSave;
var addressValueGumCurrent = state.GetValue($"{variablePrefix}Texture Address");
var textureLeftValueGumCurrent = state.GetValue($"{variablePrefix}Texture Left");
var textureWidthValueGumCurrent = state.GetValue($"{variablePrefix}Texture Width");
var textureTopValueGumCurrent = state.GetValue($"{variablePrefix}Texture Top");
var textureHeightValueGumCurrent = state.GetValue($"{variablePrefix}Texture Height");
var setsAny = addressValueGumCurrent != null ||
textureLeftValueGumCurrent != null ||
textureWidthValueGumCurrent != null ||
textureTopValueGumCurrent != null ||
textureHeightValueGumCurrent != null;
if (setsAny)
{
var rvf = new RecursiveVariableFinder(state);
var addressValueGumRecursive = rvf.GetValue <TextureAddress>($"{variablePrefix}Texture Address");
// set them all
if (addressValueGumRecursive == TextureAddress.EntireTexture)
{
// null them out:
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Left", glueElement, foundNos, null);
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Right", glueElement, foundNos, null);
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Top", glueElement, foundNos, null);
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Bottom", glueElement, foundNos, null);
}
else
{
// set the values:
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Left", glueElement, foundNos, IntToNullOrFloat(textureLeftValueGumCurrent));
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Top", glueElement, foundNos, IntToNullOrFloat(textureTopValueGumCurrent));
// right and bottom depend on left/top plus width/height
if (textureLeftValueGumCurrent != null && textureWidthValueGumCurrent != null)
{
var combined = (int)textureLeftValueGumCurrent + (int)textureWidthValueGumCurrent;
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Right", glueElement, foundNos, (float)combined);
}
else
{
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Right", glueElement, foundNos, IntToNullOrFloat(null));
}
if (textureTopValueGumCurrent != null && textureHeightValueGumCurrent != null)
{
var combined = (int)textureTopValueGumCurrent + (int)textureHeightValueGumCurrent;
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Bottom", glueElement, foundNos, (float)combined);
}
else
{
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Bottom", glueElement, foundNos, null);
}
}
}
else
{
// null them all
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Left", glueElement, foundNos, null);
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Right", glueElement, foundNos, null);
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Top", glueElement, foundNos, null);
HandleIndividualVariableAssignment(gumElement, gumInstance, "Texture Bottom", glueElement, foundNos, null);
}
handled = true;
}
return(handled);
}
public TreeNode GetTreeNodeFor(InstanceSave instanceSave, TreeNode container)
{
foreach (TreeNode node in container.Nodes)
{
if (node.Tag == instanceSave)
{
return node;
}
TreeNode childNode = GetTreeNodeFor(instanceSave, node);
if (childNode != null)
{
return childNode;
}
}
return null;
}
public void RemoveInstance(InstanceSave instanceToRemove, ElementSave elementToRemoveFrom)
{
if (!elementToRemoveFrom.Instances.Contains(instanceToRemove))
{
throw new Exception("Could not find the instance " + instanceToRemove.Name + " in " + elementToRemoveFrom.Name);
}
elementToRemoveFrom.Instances.Remove(instanceToRemove);
foreach (StateSave stateSave in elementToRemoveFrom.AllStates)
{
for (int i = stateSave.Variables.Count - 1; i > -1; i--)
{
if (stateSave.Variables[i].SourceObject == instanceToRemove.Name)
{
stateSave.Variables.RemoveAt(i);
}
}
for (int i = stateSave.VariableLists.Count - 1; i > -1; i--)
{
if (stateSave.VariableLists[i].SourceObject == instanceToRemove.Name)
{
stateSave.VariableLists.RemoveAt(i);
}
}
}
elementToRemoveFrom.Events.RemoveAll(item => item.GetSourceObject() == instanceToRemove.Name);
PluginManager.Self.InstanceDelete(elementToRemoveFrom, instanceToRemove);
if (SelectedState.Self.SelectedInstance == instanceToRemove)
{
SelectedState.Self.SelectedInstance = null;
}
}
private InstanceSave FindParentInstance(InstanceSave instance)
{
ElementSave element = instance.ParentContainer;
string name = instance.Name + ".Parent";
VariableSave variable = element.DefaultState.Variables.FirstOrDefault(v => v.Name == name);
if (variable != null && variable.SetsValue && variable.Value != null)
{
string parentName = (string) variable.Value;
return element.GetInstance(parentName);
}
return null;
}
private TreeNode AddTreeNodeForInstance(InstanceSave instance, TreeNode parentContainerNode, HashSet<InstanceSave> pendingAdditions = null)
{
TreeNode treeNode = new TreeNode();
bool validBaseType = ObjectFinder.Self.GetElementSave(instance.BaseType) != null;
if (validBaseType)
treeNode.ImageIndex = InstanceImageIndex;
else
treeNode.ImageIndex = ExclamationIndex;
treeNode.Tag = instance;
TreeNode parentNode = parentContainerNode;
InstanceSave parentInstance = FindParentInstance(instance);
if (parentInstance != null)
{
TreeNode parentInstanceNode = GetTreeNodeFor(parentInstance, parentContainerNode);
// Make sure we are not already trying to add the parent (protects against stack overflow with invalid data)
if (parentInstanceNode == null && (pendingAdditions == null || !pendingAdditions.Contains(parentInstance)))
{
if (pendingAdditions == null)
{
pendingAdditions = new HashSet<InstanceSave>();
}
pendingAdditions.Add(parentInstance);
parentInstanceNode = AddTreeNodeForInstance(parentInstance, parentContainerNode, pendingAdditions);
}
if (parentInstanceNode != null)
{
parentNode = parentInstanceNode;
}
}
parentNode.Nodes.Add(treeNode);
return treeNode;
}
// 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);
}
}
private GraphicalUiElement CreateRepresentationForInstance(InstanceSave instance, InstanceSave parentInstance, List<ElementWithState> elementStack, GraphicalUiElement container)
{
IPositionedSizedObject newIpso = null;
GraphicalUiElement graphicalElement = newIpso as GraphicalUiElement;
var baseElement = ObjectFinder.Self.GetElementSave(instance.BaseType);
string type = instance.BaseType;
if (type == "Sprite" || type == "ColoredRectangle" || type == "NineSlice" || type == "Text" || type == "Circle" || type == "Rectangle")
{
graphicalElement = new GraphicalUiElement(null, container);
ElementSave instanceBase = ObjectFinder.Self.GetElementSave(instance.BaseType);
graphicalElement.CreateGraphicalComponent(instanceBase, null);
graphicalElement.Tag = instance;
graphicalElement.Component.Name = instance.Name;
graphicalElement.Component.Tag = instance;
if (type == "Text")
{
(graphicalElement.RenderableComponent as Text).RenderBoundary = ProjectManager.Self.GeneralSettingsFile.ShowTextOutlines;
}
}
else if (instance.IsComponent())
{
newIpso = CreateRepresentationsForInstanceFromComponent(instance, elementStack, parentInstance, container, ObjectFinder.Self.GetComponent(instance.BaseType));
}
else
{
// Make sure the base type is valid.
// This could be null if a base type changed
// its name but the derived wasn't updated, or
// if someone screwed with the XML files. Who knows...
if (baseElement != null)
{
graphicalElement = new GraphicalUiElement(null, container);
CreateRectangleFor(instance, elementStack, graphicalElement);
}
}
if (newIpso != null && (newIpso is GraphicalUiElement) == false)
{
graphicalElement = new GraphicalUiElement(newIpso as IRenderable, container);
}
else if (newIpso is GraphicalUiElement)
{
graphicalElement = newIpso as GraphicalUiElement;
}
if(graphicalElement != null)
{
if (baseElement != null)
{
graphicalElement.ElementSave = baseElement;
foreach (var exposedVariable in baseElement.DefaultState.Variables.Where(item => !string.IsNullOrEmpty(item.ExposedAsName)))
{
graphicalElement.AddExposedVariable(exposedVariable.ExposedAsName, exposedVariable.Name);
}
}
var selectedState = SelectedState.Self.SelectedStateSave;
if (selectedState == null)
{
selectedState = SelectedState.Self.SelectedElement.DefaultState;
}
RecursiveVariableFinder rvf = new DataTypes.RecursiveVariableFinder(selectedState);
string guide = rvf.GetValue<string>("Guide");
string parent = rvf.GetValue<string>(instance.Name + ".Parent");
SetGuideParent(container, graphicalElement, guide, container == null || parent == AvailableInstancesConverter.ScreenBoundsName);
}
if (baseElement != null)
{
graphicalElement.SetStatesAndCategoriesRecursively(baseElement);
graphicalElement.SetVariablesRecursively(baseElement, baseElement.DefaultState);
}
return graphicalElement;
}
public void CallInstanceDelete(ElementSave elementSave, InstanceSave instance)
{
if (InstanceDelete != null)
{
InstanceDelete(elementSave, instance);
}
}
private static void SetInstanceToPosition(float worldX, float worldY, InstanceSave instance)
{
float parentX = 0;
float parentY = 0;
if (SelectedState.Self.SelectedComponent != null)
{
parentX = (float)SelectedState.Self.SelectedStateSave.GetValueRecursive("X");
parentY = (float)SelectedState.Self.SelectedStateSave.GetValueRecursive("Y");
}
// This thing may be left or center aligned so we should account for that
SelectedState.Self.SelectedStateSave.SetValue(instance.Name + ".X", worldX - parentX);
SelectedState.Self.SelectedStateSave.SetValue(instance.Name + ".Y", worldY - parentY);
}
public void CallVariableSet(ElementSave parentElement, InstanceSave instance, string changedMember, object oldValue)
{
if (VariableSet != null)
{
VariableSet(parentElement, instance, changedMember, oldValue);
}
}
internal void VariableSet(ElementSave parentElement, InstanceSave instance, string changedMember, object oldValue)
{
CallMethodOnPlugin(
delegate(PluginBase plugin)
{
plugin.CallVariableSet(parentElement, instance, changedMember, oldValue);
},
"GetAttributesFor"
);
}
private List<MemberCategory> GetCategories(ElementSave element, StateSave state, InstanceSave instance)
{
List<MemberCategory> categories = new List<MemberCategory>();
mLastElement = element;
mLastState = state;
mLastInstance = instance;
var stateSave = SelectedState.Self.SelectedStateSave;
if (stateSave != null)
{
categories.Clear();
var properties = mPropertyGridDisplayer.GetProperties(null);
foreach (InstanceSavePropertyDescriptor propertyDescriptor in properties)
{
StateReferencingInstanceMember srim;
if (instance != null)
{
srim =
new StateReferencingInstanceMember(propertyDescriptor, stateSave, instance.Name + "." + propertyDescriptor.Name, instance, element);
}
else
{
srim =
new StateReferencingInstanceMember(propertyDescriptor, stateSave, propertyDescriptor.Name, instance, element);
}
srim.SetToDefault += ResetVariableToDefault;
string category = propertyDescriptor.Category.Trim();
var categoryToAddTo = categories.FirstOrDefault(item => item.Name == category);
if (categoryToAddTo == null)
{
categoryToAddTo = new MemberCategory(category);
categories.Add(categoryToAddTo);
}
categoryToAddTo.Members.Add(srim);
}
foreach (var category in categories)
{
var enumerable = category.Members.OrderBy(item => ((StateReferencingInstanceMember)item).SortValue).ToList();
category.Members.Clear();
foreach (var value in enumerable)
{
category.Members.Add(value);
}
}
MemberCategory categoryToMove = categories.FirstOrDefault(item => item.Name == "Position");
if (categoryToMove != null)
{
categories.Remove(categoryToMove);
categories.Insert(1, categoryToMove);
}
categoryToMove = categories.FirstOrDefault(item => item.Name == "Dimensions");
if (categoryToMove != null)
{
categories.Remove(categoryToMove);
categories.Insert(2, categoryToMove);
}
UpdateColorCategory(categories);
}
return categories;
}
private IPositionedSizedObject CreateRectangleFor(InstanceSave instance, List<ElementWithState> elementStack, GraphicalUiElement graphicalUiElement)
{
ElementSave instanceBase = ObjectFinder.Self.GetElementSave(instance.BaseType);
graphicalUiElement.CreateGraphicalComponent(instanceBase, null);
graphicalUiElement.Tag = instance;
graphicalUiElement.Component.Name = instance.Name;
graphicalUiElement.Component.Tag = instance;
(graphicalUiElement.RenderableComponent as LineRectangle).LocalVisible =
GraphicalUiElement.ShowLineRectangles;
return graphicalUiElement;
}
public static VariableSave GetVariableFromThisOrBase(this InstanceSave instance,
List <ElementWithState> elementStack, RecursiveVariableFinder rvf, string variable, bool forceDefault, bool onlyIfSetsValue)
{
ElementSave instanceBase = ObjectFinder.Self.GetElementSave(instance.BaseType);
List <StateSave> statesToPullFrom;
StateSave defaultState;
GetStatesToUse(instance, elementStack, forceDefault, instanceBase, rvf, out statesToPullFrom, out defaultState);
VariableSave variableSave = null;
// See if the variable is set by the container of the instance:
foreach (var stateToPullFrom in statesToPullFrom)
{
var possibleVariable = stateToPullFrom.GetVariableSave(instance.Name + "." + variable);
if (possibleVariable != null)
{
variableSave = possibleVariable;
}
}
// non-default states can override the default state, so first
// let's see if the selected state is non-default and has a value
// for a given variable. If not, we'll fall back to the default.
if ((variableSave == null || (onlyIfSetsValue && variableSave.SetsValue == false)) && !statesToPullFrom.Contains(defaultState))
{
variableSave = defaultState.GetVariableSave(instance.Name + "." + variable);
}
// Still haven't found a variable yet, so look in the instanceBase if one exists
if ((variableSave == null ||
(onlyIfSetsValue && (variableSave.SetsValue == false || variableSave.Value == null))) && instanceBase != null)
{
VariableSave foundVariableSave = TryGetVariableFromStatesOnInstance(instance, variable, instanceBase, statesToPullFrom);
if (foundVariableSave != null)
{
variableSave = foundVariableSave;
}
}
// I don't think we have to do this because we're going to copy over
// the variables to all components on load.
//if (variableSave == null && instanceBase != null && instanceBase is ComponentSave)
//{
// variableSave = StandardElementsManager.Self.DefaultStates["Component"].GetVariableSave(variable);
//}
if (variableSave != null && variableSave.Value == null && instanceBase != null && onlyIfSetsValue)
{
// This can happen if there is a tunneled variable that is null
VariableSave possibleVariable = instanceBase.DefaultState.GetVariableSave(variable);
if (possibleVariable != null && possibleVariable.Value != null && (!onlyIfSetsValue || possibleVariable.SetsValue))
{
variableSave = possibleVariable;
}
else if (!string.IsNullOrEmpty(instanceBase.BaseType))
{
ElementSave element = ObjectFinder.Self.GetElementSave(instanceBase.BaseType);
if (element != null)
{
variableSave = element.GetVariableFromThisOrBase(variable, forceDefault);
}
}
}
return(variableSave);
}
private GraphicalUiElement CreateRepresentationsForInstanceFromComponent(InstanceSave instance,
List<ElementWithState> elementStack, InstanceSave parentInstance, GraphicalUiElement parentIpso,
ComponentSave baseComponentSave)
{
StandardElementSave ses = ObjectFinder.Self.GetRootStandardElementSave(instance);
GraphicalUiElement rootIpso = null;
if (ses != null)
{
rootIpso = new GraphicalUiElement(null, parentIpso);
string type = ses.Name;
if (type == "Sprite" || type == "ColoredRectangle" || type == "NineSlice" || type == "Text" || type == "Circle" || type == "Rectangle")
{
ElementSave instanceBase = ObjectFinder.Self.GetElementSave(instance.BaseType);
rootIpso.CreateGraphicalComponent(instanceBase, null);
rootIpso.Tag = instance;
rootIpso.Component.Name = instance.Name;
rootIpso.Component.Tag = instance;
if(type == "Text")
{
(rootIpso.RenderableComponent as Text).RenderBoundary = ProjectManager.Self.GeneralSettingsFile.ShowTextOutlines;
}
}
else
{
CreateRectangleFor(instance, elementStack, rootIpso);
}
var selectedState = SelectedState.Self.SelectedStateSave;
if (selectedState == null)
{
selectedState = SelectedState.Self.SelectedElement.DefaultState;
}
RecursiveVariableFinder rvf = new DataTypes.RecursiveVariableFinder(selectedState);
string guide = rvf.GetValue<string>("Guide");
SetGuideParent(parentIpso, rootIpso, guide, false);
ElementWithState elementWithState = new ElementWithState(baseComponentSave);
var tempRvf = new DataTypes.RecursiveVariableFinder(instance, elementStack);
var state = tempRvf.GetValue("State") as string;
elementWithState.StateName = state;
foreach (var category in baseComponentSave.Categories)
{
elementWithState.CategorizedStates.Add(category.Name, tempRvf.GetValue<string>(category.Name + "State"));
}
elementWithState.InstanceName = instance.Name;
elementStack.Add(elementWithState);
foreach (InstanceSave internalInstance in baseComponentSave.Instances)
{
GraphicalUiElement createdIpso = CreateRepresentationForInstance(internalInstance, instance, elementStack, rootIpso);
}
SetUpParentRelationship(rootIpso.ContainedElements, elementStack, baseComponentSave.Instances);
elementStack.Remove(elementStack.FirstOrDefault(item => item.Element == baseComponentSave));
}
return rootIpso;
}
public static bool GetIsFileFromRoot(this VariableSave variable, InstanceSave instance)
{
if (string.IsNullOrEmpty(variable.SourceObject))
{
ElementSave root = ObjectFinder.Self.GetRootStandardElementSave(instance);
var variableInRoot = root.DefaultState.Variables.FirstOrDefault(item => item.Name == variable.GetRootName());
if (variableInRoot != null)
{
return variableInRoot.IsFile;
}
}
else
{
ElementSave elementForInstance = ObjectFinder.Self.GetElementSave(instance.BaseType);
string rootName = variable.GetRootName();
VariableSave exposedVariable = elementForInstance.DefaultState.Variables.FirstOrDefault(item => item.ExposedAsName == rootName);
if (exposedVariable != null)
{
InstanceSave subInstance = elementForInstance.Instances.FirstOrDefault(item => item.Name == exposedVariable.SourceObject);
if (subInstance != null)
{
return exposedVariable.GetIsFileFromRoot(subInstance);
}
}
else
{
// it's not exposed, so let's just get to the root of it:
ElementSave root = ObjectFinder.Self.GetRootStandardElementSave(instance);
var variableInRoot = root.DefaultState.Variables.FirstOrDefault(item => item.Name == variable.GetRootName());
if (variableInRoot != null)
{
return variableInRoot.IsFile;
}
}
}
return false;
}
public void CallInstanceSelected(ElementSave elementSave, InstanceSave instance)
{
if (InstanceSelected != null)
{
InstanceSelected(elementSave, instance);
}
}
private static void AskToDeleteInstance(InstanceSave instance)
{
DialogResult result =
MessageBox.Show("Are you sure you'd like to delete " + instance.Name + "?", "Delete instance?", MessageBoxButtons.YesNo);
if (result == DialogResult.Yes)
{
ElementSave selectedElement = SelectedState.Self.SelectedElement;
Gum.ToolCommands.ElementCommands.Self.RemoveInstance(instance, selectedElement);
RefreshAndSaveAfterInstanceRemoval(selectedElement);
}
}
public void ReactToRenamed(ElementSave element, InstanceSave instance, string oldName)
{
if (instance == null)
{
List<ElementReference> listToSearch = null;
if (element is ScreenSave)
{
listToSearch = ScreenReferences;
}
else if (element is ComponentSave)
{
listToSearch = ComponentReferences;
}
else if (element is StandardElementSave)
{
listToSearch = StandardElementReferences;
}
foreach (ElementReference reference in listToSearch)
{
if (reference.Name == oldName)
{
reference.Name = element.Name;
}
}
}
}
private void PastedCopiedInstance(InstanceSave sourceInstance, ElementSave sourceElement, ElementSave targetElement, InstanceSave targetInstance, StateSave copiedState)
{
targetInstance.Name = StringFunctions.MakeStringUnique(targetInstance.Name, targetElement.Instances.Select(item=>item.Name));
targetElement.Instances.Add(targetInstance);
// We now have to copy over the states
if (targetElement != sourceElement)
{
if (sourceElement.States.Count != 1)
{
MessageBox.Show("Only the default state variables will be copied since the source and target elements differ.");
}
StateSave stateSave = copiedState;
// Why do we reverse loop here?
for (int i = stateSave.Variables.Count - 1; i > -1; i--)
{
VariableSave sourceVariable = stateSave.Variables[i];
VariableSave copiedVariable = sourceVariable.Clone();
// Only copy over the variables that apply to the object that was dropped
if (sourceVariable.SourceObject == sourceInstance.Name)
{
copiedVariable.Name = targetInstance.Name + "." + copiedVariable.GetRootName();
// We don't want to copy exposed variables.
// If we did, the user would have 2 variables exposed with the same.
copiedVariable.ExposedAsName = null;
targetElement.DefaultState.Variables.Add(copiedVariable);
}
}
for(int i = 0; i < stateSave.VariableLists.Count; i++)
{
var sourceVariableList = stateSave.VariableLists[i];
var copiedVariableList = sourceVariableList.Clone();
// Only copy over the variables that apply to the object that was dropped
if (sourceVariableList.SourceObject == sourceInstance.Name)
{
copiedVariableList.Name = targetInstance.Name + "." + copiedVariableList.GetRootName();
copiedVariableList.SourceObject = targetInstance.Name;
targetElement.DefaultState.VariableLists.Add(copiedVariableList);
}
}
}
else
{
StateSave stateSave = copiedState;
for (int i = stateSave.Variables.Count - 1; i > -1; i--)
{
// We may have copied over a group of instances. If so
// the copied state may have variables for multiple instances.
// We only want to apply the variables that work for the selected
// object.
VariableSave sourceVariable = stateSave.Variables[i];
if (sourceVariable.SourceObject == sourceInstance.Name)
{
VariableSave copiedVariable = sourceVariable.Clone();
copiedVariable.Name = targetInstance.Name + "." + copiedVariable.GetRootName();
// We don't want to copy exposed variables.
// If we did, the user would have 2 variables exposed with the same.
copiedVariable.ExposedAsName = null;
SelectedState.Self.SelectedStateSave.Variables.Add(copiedVariable);
}
}
// Copy over the VariableLists too
for (int i = stateSave.VariableLists.Count - 1; i > -1; i--)
{
VariableListSave sourceList = stateSave.VariableLists[i];
if (sourceList.SourceObject == sourceInstance.Name)
{
VariableListSave copiedList = sourceList.Clone();
copiedList.Name = targetInstance.Name + "." + copiedList.GetRootName();
copiedList.SourceObject = targetInstance.Name;
SelectedState.Self.SelectedStateSave.VariableLists.Add(copiedList);
}
}
}
// This used to be done here when we paste, but now we're
// going to remove it when the cut happens - just like text
// editors. Undo will handle this if we mess up.
// bool shouldSaveSource = false;
//if (mIsCtrlXCut)
//{
// if (sourceElement.Instances.Contains(sourceInstance))
// {
// // Not sure why we weren't just using
// // ElementCommands here - maybe an oversight?
// // This should improve things like
// //sourceElement.Instances.Remove(sourceInstance);
// ElementCommands.Self.RemoveInstance(sourceInstance, sourceElement);
// shouldSaveSource = true;
// }
//}
targetInstance.ParentContainer = targetElement;
// We need to call InstanceAdd before we select the new object - the Undo manager expects it
// This includes before other managers refresh
PluginManager.Self.InstanceAdd(targetElement, targetInstance);
WireframeObjectManager.Self.RefreshAll(true);
GumCommands.Self.GuiCommands.RefreshElementTreeView(targetElement);
SelectedState.Self.SelectedInstance = targetInstance;
GumCommands.Self.FileCommands.TryAutoSaveElement(targetElement);
}
