private static object TryToGetStateCategoryFromElement(string memberName, IElement element) { object foundObject = null; StateSaveCategory existingCategory = element.GetStateCategoryRecursively(memberName); bool isUncategorizedCategory = memberName == "VariableState"; if (!isUncategorizedCategory) { if (existingCategory != null) { if (existingCategory.SharesVariablesWithOtherCategories == false) { foundObject = existingCategory; } else { isUncategorizedCategory = true; } } } if (isUncategorizedCategory) { StateSaveCategory stateSaveCategory = new StateSaveCategory(); foreach (StateSave stateSave in element.States) { stateSaveCategory.States.Add(stateSave); } foundObject = stateSaveCategory; } return(foundObject); }
public StateSaveCategory AddCategory(ElementSave elementToAddTo, string name) { if (elementToAddTo == null) { throw new Exception("Could not add category " + name + " because no element is selected"); } StateSaveCategory category = new StateSaveCategory(); category.Name = name; elementToAddTo.Categories.Add(category); string categoryName = category.Name + "State"; elementToAddTo.DefaultState.Variables.Add(new VariableSave() { Name = categoryName, Type = categoryName, Value = null #if GUM , CustomTypeConverter = new Gum.PropertyGridHelpers.Converters.AvailableStatesConverter(category.Name) #endif }); elementToAddTo.DefaultState.Variables.Sort((first, second) => first.Name.CompareTo(second.Name)); return(category); }
public static BehaviorSave CreateButtonBehavior() { BehaviorSave toReturn = new BehaviorSave(); toReturn.Name = ButtonBehaviorName; var category = new StateSaveCategory(); toReturn.Categories.Add(category); category.Name = "ButtonCategory"; category.States.Add(new StateSave { Name = "Enabled" }); category.States.Add(new StateSave { Name = "Disabled" }); category.States.Add(new StateSave { Name = "Highlighted" }); category.States.Add(new StateSave { Name = "Pushed" }); return(toReturn); }
private void Remove(StateSaveCategory category) { var stateCategoryListContainer = SelectedState.Self.SelectedStateContainer as IStateCategoryListContainer; stateCategoryListContainer.Categories.Remove(category); if (SelectedState.Self.SelectedElement != null) { var element = SelectedState.Self.SelectedElement; foreach (var state in element.AllStates) { for (int i = state.Variables.Count - 1; i > -1; i--) { var variable = state.Variables[i]; if (variable.Type == category.Name + "State") { state.Variables.RemoveAt(i); } } } } GumCommands.Self.FileCommands.TryAutoSaveCurrentElement(); StateTreeViewManager.Self.RefreshUI(SelectedState.Self.SelectedStateContainer); PropertyGridManager.Self.RefreshUI(); WireframeObjectManager.Self.RefreshAll(true); SelectionManager.Self.Refresh(); PluginManager.Self.CategoryDelete(category); }
private void RefreshStateLabel(ElementSave element, StateSaveCategory category, StateSave state) { if (element == null) { variableViewModel.HasStateInformation = System.Windows.Visibility.Collapsed; } else if (state == element.DefaultState || state == null) { variableViewModel.HasStateInformation = System.Windows.Visibility.Collapsed; } else if (SelectedState.Self.CustomCurrentStateSave != null) { variableViewModel.HasStateInformation = System.Windows.Visibility.Visible; variableViewModel.StateInformation = $"Displaying custom (animated) state"; variableViewModel.StateBackground = Brushes.Pink; } else { variableViewModel.StateBackground = Brushes.Yellow; variableViewModel.HasStateInformation = System.Windows.Visibility.Visible; string stateName = state.Name; if (category != null) { stateName = category.Name + "/" + stateName; } variableViewModel.StateInformation = $"Editing state {stateName}"; } }
public static EntitySave CreateEntitySaveWithStates(string name) { EntitySave entitySave = new EntitySave(); entitySave.Name = name; StateSaveCategory category = new StateSaveCategory(); category.Name = "StateCategory"; StateSave stateSave = new StateSave(); stateSave.Name = "StateInCategory1"; category.SharesVariablesWithOtherCategories = false; category.States.Add(stateSave); entitySave.StateCategoryList.Add(category); StateSave uncategoried = new StateSave(); uncategoried.Name = "Uncategorized"; entitySave.States.Add(uncategoried); return(entitySave); }
public void AddCategory() { var target = SelectedState.Self.SelectedStateContainer as IStateCategoryListContainer; if (target == null) { MessageBox.Show("You must first select an element or behavior to add a state category"); } else { TextInputWindow tiw = new TextInputWindow(); tiw.Message = "Enter new category name:"; if (tiw.ShowDialog() == DialogResult.OK) { string name = tiw.Result; StateSaveCategory category = ElementCommands.Self.AddCategory( target, name); ElementTreeViewManager.Self.RefreshUi(SelectedState.Self.SelectedStateContainer); StateTreeViewManager.Self.RefreshUI(SelectedState.Self.SelectedStateContainer); SelectedState.Self.SelectedStateCategorySave = category; GumCommands.Self.FileCommands.TryAutoSaveCurrentObject(); } } }
public StateCategoryViewModel(StateSaveCategory category, IElement element) { this.VariableManagementVisibility = Visibility.Collapsed; this.Element = element; this.category = category; Columns = new List <string>(); States = new ObservableCollection <StateViewModel>(); foreach (var state in category.States) { var stateViewModel = new StateViewModel(state, category, element); AssignEventsOn(stateViewModel); States.Add(stateViewModel); } CreateBlankViewModelAtEnd(element); IncludedVariables = new ObservableCollection <string>(); ExcludedVariables = new ObservableCollection <string>(); ExcludedVariables.CollectionChanged += HandleExcludedVariablesChanged; RefreshExcludedAndIncludedVariables(); this.Name = category.Name; this.PropertyChanged += HandlePropertyChanged; }
public StateViewModel(StateSave state, StateSaveCategory category, IElement element) { this.category = category; this.element = element; BackingData = state; Variables = new ObservableCollection <StateVariableViewModel>(); Name = state?.Name; for (int i = 0; i < element.CustomVariables.Count; i++) { var variable = element.CustomVariables[i]; // see if there is a value for this variable var instruction = state?.InstructionSaves.FirstOrDefault(item => item.Member == variable.Name); var viewModel = new StateVariableViewModel(); viewModel.VariableName = variable.Name; viewModel.Value = instruction?.Value; viewModel.DefaultValue = element.GetCustomVariable(variable.Name)?.DefaultValue; viewModel.PropertyChanged += HandleStateVariablePropertyChanged; viewModel.HasState = state != null; this.Variables.Add(viewModel); } }
public void RemoveStateCategory(StateSaveCategory category, IStateCategoryListContainer stateCategoryListContainer) { // This category can only be removed if no behaviors require it var behaviorsNeedingCategory = GetBehaviorsNeedingCategory(category, stateCategoryListContainer as ComponentSave); if (behaviorsNeedingCategory.Any()) { string message = "This category cannot be removed because it is needed by the following behavior(s):"; foreach (var behavior in behaviorsNeedingCategory) { message += "\n" + behavior.Name; } MessageBox.Show(message); } else { var response = MessageBox.Show($"Are you sure you want to delete the category {category.Name}?", "Delete category?", MessageBoxButtons.YesNo); if (response == DialogResult.Yes) { Remove(category); } } }
public void UpdateToStateCategory(StateSaveCategory stateSaveCategory) { TreeNode treeNode = GetTreeNodeFor(stateSaveCategory); if (treeNode == null) { treeNode = new TreeNode(stateSaveCategory.Name); treeNode.ForeColor = ElementViewWindow.StateCategoryColor; treeNode.ImageKey = "folder.png"; treeNode.SelectedImageKey = "folder.png"; this.Nodes.Add(treeNode); } if (treeNode.Text != stateSaveCategory.Name) { treeNode.Text = stateSaveCategory.Name; } if (treeNode.Tag != stateSaveCategory) { treeNode.Tag = stateSaveCategory; } UpdateStateContainingNode(stateSaveCategory.States, treeNode); }
public ElementSave GetContainerOf(StateSaveCategory category) { if (GumProjectSave != null) { foreach (var screen in GumProjectSave.Screens) { if (screen.Categories.Contains(category)) { return(screen); } } foreach (var component in GumProjectSave.Components) { if (component.Categories.Contains(category)) { return(component); } } foreach (var standardElement in GumProjectSave.StandardElements) { if (standardElement.Categories.Contains(category)) { return(standardElement); } } } return(null); }
private static BehaviorSave CreateBehaviorSaveFrom(FormsControlInfo controlInfo) { BehaviorSave toReturn = new BehaviorSave(); toReturn.Name = controlInfo.BehaviorName; foreach (var gumStateCategory in controlInfo.GumStateCategory) { var category = new StateSaveCategory(); toReturn.Categories.Add(category); category.Name = gumStateCategory.Name; if (gumStateCategory.States != null) { foreach (var stateName in gumStateCategory.States) { category.States.Add(new StateSave { Name = stateName }); } } } return(toReturn); }
public void AskRemoveVariableFromAllStatesInCategory(string variableName, StateSaveCategory stateCategory) { string message = $"Are you sure you want to remove {variableName} from all states in {stateCategory.Name}? The following states will be impacted:\n"; foreach (var state in stateCategory.States) { message += $"\n{state.Name}"; } var result = MessageBox.Show(message, "Remove Variables?", MessageBoxButtons.YesNo); if (result == DialogResult.Yes) { foreach (var state in stateCategory.States) { var foundVariable = state.Variables.FirstOrDefault(item => item.Name == variableName); if (foundVariable != null) { state.Variables.Remove(foundVariable); } } // save everything GumCommands.Self.FileCommands.TryAutoSaveCurrentElement(); GumCommands.Self.GuiCommands.RefreshStateTreeView(); // no selection has changed, but we want to force refresh here because we know // we really need a refresh - something was removed. GumCommands.Self.GuiCommands.RefreshPropertyGrid(force: true); } }
private void HandleCategoryRename(StateSaveCategory category, string oldName) { var elementSave = ObjectFinder.Self.GetContainerOf(category); if (elementSave != null) { foreach (var state in elementSave.AllStates) { var variablesToChange = state.Variables.Where( item => item.Type == oldName + "State"); foreach (var variable in variablesToChange) { variable.Name = category.Name + "State"; variable.Type = category.Name + "State"; #if GUM variable.CustomTypeConverter = new Gum.PropertyGridHelpers.Converters.AvailableStatesConverter(category.Name); #endif } state.Variables.Sort((first, second) => first.Name.CompareTo(second.Name)); } } }
public void CallStateCategoryRename(StateSaveCategory category, string oldName) { if (CategoryRename != null) { CategoryRename(category, oldName); } }
private void AddCategoriesFromBehavior(BehaviorSave behaviorSave, ComponentSave component) { foreach (var behaviorCategory in behaviorSave.Categories) { StateSaveCategory matchingComponentCategory = component.Categories.FirstOrDefault(item => item.Name == behaviorCategory.Name); if (matchingComponentCategory == null) { //category doesn't exist, so let's add a clone of it: matchingComponentCategory = new StateSaveCategory(); matchingComponentCategory.Name = behaviorCategory.Name; component.Categories.Add(matchingComponentCategory); } foreach (var behaviorState in behaviorCategory.States) { var matchingComponentState = matchingComponentCategory.States.FirstOrDefault(item => item.Name == behaviorState.Name); if (matchingComponentState == null) { // state doesn't exist, so add it: var newState = new StateSave(); newState.Name = behaviorState.Name; newState.ParentContainer = component; matchingComponentCategory.States.Add(newState); } } } }
private string GetWhySharesVariableChangeIsntAllowed(StateSaveCategory category, IElement element) { string toReturn = null; if (category.SharesVariablesWithOtherCategories) { // Shares, which means we need to go through all uncategorized and all other categories that share to see if there's any matches foreach (var state in category.States) { if (element.States.Exists(item => item.Name == state.Name)) { toReturn = "There is already an uncategorized state named " + state.Name + " which would conflict with the state in " + category.Name; break; } foreach (var otherCategory in element.StateCategoryList.Where(item => item.SharesVariablesWithOtherCategories && item != category)) { if (otherCategory.States.Exists(item => item.Name == state.Name)) { toReturn = "There is already a state in the category " + otherCategory.Name + " with the name " + state.Name; break; } } } } return(toReturn); }
public StateSave AddState(ElementSave elementToAddTo, StateSaveCategory category, string name) { // elementToAddTo may be null if category is not null if (elementToAddTo == null && category == null) { throw new Exception("Could not add state named " + name + " because no element is selected"); } StateSave stateSave = new StateSave(); stateSave.Name = name; AddState(elementToAddTo, category, stateSave); var otherState = category?.States.FirstOrDefault(item => item != stateSave); if (otherState != null) { foreach (var variable in otherState.Variables) { VariableInCategoryPropagationLogic.Self .PropagateVariablesInCategory(variable.Name); } } return(stateSave); }
private static void MoveStateCategory(TreeNode nodeMoving, TreeNode targetNode) { if (targetNode.IsRootCustomVariablesNode() || targetNode.IsCustomVariable()) { // The user drag+dropped a state category into the variables // Let's make sure that it's all in the same Element though: if (targetNode.GetContainingElementTreeNode() == nodeMoving.GetContainingElementTreeNode()) { StateSaveCategory category = nodeMoving.Tag as StateSaveCategory; // expose a variable that exposes the category CustomVariable customVariable = new CustomVariable(); if (category.SharesVariablesWithOtherCategories) { customVariable.Type = "VariableState"; customVariable.Name = "CurrentState"; } else { customVariable.Type = category.Name; customVariable.Name = "Current" + category.Name + "State"; } IElement element = targetNode.GetContainingElementTreeNode().Tag as IElement; element.CustomVariables.Add(customVariable); GlueCommands.Self.GenerateCodeCommands.GenerateCurrentElementCode(); EditorLogic.CurrentElementTreeNode.UpdateReferencedTreeNodes(); } } }
private void ShowCategory(StateSaveCategory currentStateSaveCategory) { if (control == null) { control = new StateDataControl(); // continue here by either creating a new VM or modifying the existing // to have columns set from the element's variables this.AddToTab(PluginManager.CenterTab, control, "State Data"); } else { this.AddTab(); } var viewModel = new StateCategoryViewModel(currentStateSaveCategory, GlueState.Self.CurrentElement); var variablesToConsider = GlueState.Self.CurrentElement.CustomVariables .Where(item => item.IsShared == false) .ToList(); foreach (var variable in variablesToConsider) { viewModel.Columns.Add(variable.Name); } control.DataContext = viewModel; control.RefreshColumns(); }
internal void AddStateCategoryClick() { if (SelectedState.Self.SelectedElement == null) { MessageBox.Show("You must first select an element to add a state category"); } else { TextInputWindow tiw = new TextInputWindow(); tiw.Message = "Enter new category name:"; if (tiw.ShowDialog() == DialogResult.OK) { string name = tiw.Result; StateSaveCategory category = ElementCommands.Self.AddCategory( SelectedState.Self.SelectedElement, name); RefreshUI(SelectedState.Self.SelectedElement); SelectedState.Self.SelectedStateCategorySave = category; GumCommands.Self.FileCommands.TryAutoSaveCurrentElement(); } } }
public void AddCategory() { var target = SelectedState.Self.SelectedStateContainer as IStateCategoryListContainer; if (target == null) { MessageBox.Show("You must first select an element or behavior to add a state category"); } else { TextInputWindow tiw = new TextInputWindow(); tiw.Message = "Enter new category name:"; var canAdd = true; var result = tiw.ShowDialog(); if (result != DialogResult.OK) { canAdd = false; } string name = null; if (canAdd) { name = tiw.Result; // see if any base elements have thsi category if (target is ElementSave element) { var existingCategory = element.GetStateSaveCategoryRecursively(name, out ElementSave categoryContainer); if (existingCategory != null) { MessageBox.Show($"Cannot add category - a category with the name {name} is already defined in {categoryContainer}"); canAdd = false; } } } if (canAdd) { StateSaveCategory category = ElementCommands.Self.AddCategory( target, name); ElementTreeViewManager.Self.RefreshUi(SelectedState.Self.SelectedStateContainer); StateTreeViewManager.Self.RefreshUI(SelectedState.Self.SelectedStateContainer); PluginManager.Self.CategoryAdd(category); SelectedState.Self.SelectedStateCategorySave = category; GumCommands.Self.FileCommands.TryAutoSaveCurrentObject(); } } }
public void TestExposingStates() { List <string> variables = ExposedVariableManager.GetExposableMembersFor(mEntitySave, false).Select(m => m.Member).ToList(); if (!variables.Contains("CurrentState")) { throw new Exception("ExposedVariableManager is not properly returning the CurrentState as an exposable variable"); } if (!variables.Contains("CurrentStateCategoryState")) { throw new Exception("ExposedVariableManager is not properly returning categorized states as exposable variables"); } // Let's remove uncategorized state to make sure the categorized state is still recognized: StateSave stateSave = mEntitySave.States[0]; mEntitySave.States.RemoveAt(0); variables = ExposedVariableManager.GetExposableMembersFor(mEntitySave, false).Select(m => m.Member).ToList(); if (!variables.Contains("CurrentStateCategoryState")) { throw new Exception("ExposedVariableManager is not properly returning categorized states when there are no uncategorized states."); } // Add it back in case it's needed for other tests. mEntitySave.States.Add(stateSave); variables = ExposedVariableManager.GetExposableMembersFor(mEntityWithCategorizedThatShareVariables, false).Select(m => m.Member).ToList(); if (!variables.Contains("CurrentState")) { throw new Exception("Entities that only have states in categories, but those categories share variables with other categories, are not exposing CurrentState and they should!"); } List <string> listOfStates = new List <string>(); AvailableStates availableStates = new AvailableStates(null, mContainerDerivedEntity, mContainerDerivedEntity.CustomVariables[0], null); availableStates.GetListOfStates(listOfStates, "TunneledStateVariable"); if (listOfStates.Count == 0 || !listOfStates.Contains("StateInCategory1")) { throw new Exception("SetByDerived variables that tunnel in to categorized states do not properly return their list through GetListOfStates"); } ScreenSave screenSave = new ScreenSave(); StateSaveCategory category = new StateSaveCategory(); category.Name = "Whatever"; screenSave.StateCategoryList.Add(category); StateSave stateInScreen = new StateSave(); stateInScreen.Name = "First"; category.States.Add(stateInScreen); variables = ExposedVariableManager.GetExposableMembersFor(screenSave, false).Select(item => item.Member).ToList(); if (variables.Contains("CurrentState") == false) { throw new NotImplementedException("Screens with states that are in categories that share variables are not properly returning the CurrentState as a possible variable"); } }
private void UpdateCategoryTreeNode(StateSaveCategory category) { var node = GetTreeNodeForTag(category); if (node.Text != category.Name) { node.Text = category.Name; } }
public void Update(string containerName, StateSaveCategory stateSaveCategory) { var container = ObjectFinder.Self.GetIElement(containerName); var currentNos = container.GetStateCategory(stateSaveCategory.Name); CopyObject(stateSaveCategory, currentNos); RefreshElement(container); //GlueCommand.GluxCommands.SaveGlux(); }
public void ReactToStateSaveCategoryChangedValue(StateSaveCategory stateSaveCategory, string changedMember, object oldValue, IElement element, ref bool updateTreeView) { if (changedMember == "SharesVariablesWithOtherCategories") { string oldType; string newType; if ((bool)oldValue == true) { oldType = "VariableState"; newType = stateSaveCategory.Name; } else { oldType = stateSaveCategory.Name; newType = "VariableState"; } string whyIsntAllowed = GetWhySharesVariableChangeIsntAllowed(stateSaveCategory, element); if (!string.IsNullOrEmpty(whyIsntAllowed)) { MessageBox.Show(whyIsntAllowed); stateSaveCategory.SharesVariablesWithOtherCategories = false; } else { // See if any variables are using this. If so, let's change them // We need to see if any variables are already tunneling in to this // new type. If so, then notify the user that the variable will be removed. // Otherwise, notify the user that the variable type is changing. foreach (CustomVariable customVariable in element.CustomVariables) { if (customVariable.Type == oldType && !string.IsNullOrEmpty(customVariable.DefaultValue as string) && stateSaveCategory.GetState(customVariable.DefaultValue as string) != null) { // We need to do something here... bool shouldChange = false; #if !UNIT_TESTS var dialogResult = System.Windows.Forms.MessageBox.Show("Change variable " + customVariable.Name + " to be of type " + newType + " ? Selecting 'No' will introduce compile errors.", "Change variable type?", System.Windows.Forms.MessageBoxButtons.YesNo); if (dialogResult == System.Windows.Forms.DialogResult.Yes) { shouldChange = true; } #else shouldChange = true; #endif if (shouldChange) { customVariable.Type = newType; } } } } } }
internal void CategoryRename(StateSaveCategory category, string oldName) { CallMethodOnPlugin( delegate(PluginBase plugin) { plugin.CallStateCategoryRename(category, oldName); }, "CategoryRename" ); }
public void Initialize() { OverallInitializer.Initialize(); ExposedVariableManager.Initialize(); mEntitySave = CreateEntitySaveWithStates("ExposedVariableEntity"); mEntitySave.ImplementsIVisible = true; ObjectFinder.Self.GlueProject.Entities.Add(mEntitySave); mDerivedEntitySave = new EntitySave(); mDerivedEntitySave.BaseEntity = mEntitySave.Name; mDerivedEntitySave.Name = "DerivedExposedVariableEntity"; ObjectFinder.Self.GlueProject.Entities.Add(mDerivedEntitySave); mEntityWithCategorizedThatShareVariables = new EntitySave(); mEntityWithCategorizedThatShareVariables.Name = "ExposedVariableTestEntityWithCategorizedThatShareVariables"; ObjectFinder.Self.GlueProject.Entities.Add(mEntityWithCategorizedThatShareVariables); StateSaveCategory category = new StateSaveCategory(); category.SharesVariablesWithOtherCategories = true; // this is important - it means that it won't make a new enum or property, so it is just the "CurrentState" variable category.Name = "Category1"; mEntityWithCategorizedThatShareVariables.StateCategoryList.Add(category); StateSave stateSave = new StateSave(); stateSave.Name = "CategorizedState1"; category.States.Add(stateSave); mContainerBaseEntity = new EntitySave(); mContainerBaseEntity.Name = "ExposedVariableTestContainerBaseEntity"; ObjectFinder.Self.GlueProject.Entities.Add(mContainerBaseEntity); NamedObjectSave namedObjectSave = new NamedObjectSave(); namedObjectSave.InstanceName = mEntitySave.Name + "Instance"; namedObjectSave.SourceType = SourceType.Entity; namedObjectSave.SourceClassType = mEntitySave.Name; mContainerBaseEntity.NamedObjects.Add(namedObjectSave); CustomVariable tunneledVariable = new CustomVariable(); tunneledVariable.Name = "TunneledStateVariable"; tunneledVariable.SourceObject = namedObjectSave.InstanceName; tunneledVariable.SourceObjectProperty = "Current" + mEntitySave.StateCategoryList[0].Name + "State"; tunneledVariable.Type = mEntitySave.StateCategoryList[0].Name; tunneledVariable.SetByDerived = true; mContainerBaseEntity.CustomVariables.Add(tunneledVariable); mContainerDerivedEntity = new EntitySave(); mContainerDerivedEntity.Name = "ExposedVariableTestContainerDerivedEntity"; ObjectFinder.Self.GlueProject.Entities.Add(mContainerDerivedEntity); mContainerDerivedEntity.BaseEntity = mContainerBaseEntity.Name; mContainerDerivedEntity.UpdateFromBaseType(); mContainerDerivedEntity.GetCustomVariable(tunneledVariable.Name).DefaultValue = mEntitySave.StateCategoryList[0].States[0].Name; CreateCsvContainerEntitySave(); }
public TreeNode StateCategoryTreeNode(StateSaveCategory category) { TreeNode treeNode = TreeNodeByTagIn(category, ElementViewWindow.ScreensTreeNode.Nodes); if (treeNode == null) { treeNode = TreeNodeByTagIn(category, ElementViewWindow.EntitiesTreeNode.Nodes); } return(treeNode); }