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 void Initialize()
        {
            Container.Set(new StateSaveCategorySetVariableLogic());

            mEntitySave = new EntitySave();

            mCategory = new StateSaveCategory();
            mCategory.Name = "Category1";
            mCategory.SharesVariablesWithOtherCategories = true;
            mEntitySave.StateCategoryList.Add(mCategory);

            mCategory2 = new StateSaveCategory();
            mCategory2.Name = "Category2";
            mCategory2.SharesVariablesWithOtherCategories = true;
            mEntitySave.StateCategoryList.Add(mCategory);

            StateSave state1 = new StateSave();
            state1.Name = "State1";
            mCategory.States.Add(state1);

            StateSave stateInCategory2 = new StateSave();
            stateInCategory2.Name = "State1InCategory2";
            mCategory2.States.Add(stateInCategory2);


            mCustomVariable = new CustomVariable();
            mCustomVariable.Name = "CurrentState";
            mCustomVariable.Type = "VariableState";
            mCustomVariable.DefaultValue = "State1";
            mEntitySave.CustomVariables.Add(mCustomVariable);

             //need to test the case where a variable shouldn't be changed because it's not part of the category that got changed.
             //Also, need to handle a case where the variable becomes an uncategorized variable, but there alread is one...do we allow it?
        }
        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;
                            }
                        }
                    }
                }
            }
        }
示例#4
0
        TreeNode GetTreeNodeFor(StateSaveCategory category)
        {
            foreach (TreeNode treeNode in this.Nodes)
            {
                if (treeNode.Tag == category)
                {
                    return treeNode;
                }
            }

            return null;
        }
        public void ReactToStateSaveChangedValue(StateSave stateSave, StateSaveCategory category, string changedMember, object oldValue, IElement parentObject, ref bool updateTreeView)
        {
            if (changedMember != "Name")
            {
                updateTreeView = false;
            }

            // See if this is an Unmodified object
            // We don't support NamedObjectPropertyOverrides anymore
            //NamedObjectPropertyOverride propertyOverride = parentObject as NamedObjectPropertyOverride;
            //if (propertyOverride != null)
            //{
            //    if (stateSave.NamedObjectPropertyOverrides.Contains(propertyOverride))
            //    {
            //        if (changedMember == "SourceFile" && propertyOverride.SourceFile == AvailableFileStringConverter.UseDefaultString)
            //        {
            //            propertyOverride.SourceFile = null;
            //        }

            //        if (propertyOverride.IsNulledOut)
            //        {
            //            stateSave.NamedObjectPropertyOverrides.Remove(propertyOverride);
            //        }
            //    }
            //    else
            //    {
            //        switch (changedMember)
            //        {
            //            case "SourceFile":
            //                propertyOverride.SourceFile = NamedObjectPropertyOverride.SourceFileBuffer;
            //                break;
            //        }
            //        stateSave.NamedObjectPropertyOverrides.Add(propertyOverride);
            //    }
            //}

            if (changedMember == "Name")
            {
                string whyItIsntValid;
                if (!NameVerifier.IsStateNameValid(stateSave.Name, EditorLogic.CurrentElement, EditorLogic.CurrentStateSaveCategory, EditorLogic.CurrentStateSave, out whyItIsntValid))
                {
                    stateSave.Name = (string)oldValue;
                    updateTreeView = false;
                    AutomatedGlue.GlueGui.ShowMessageBox(whyItIsntValid);

                }
                else
                {
                    ReactToStateNameChange(oldValue, stateSave, category, parentObject);
                }
            }
        }
示例#6
0
        private GumStateCategory ToGumStateCategory(GlueStateCategory glueStateCategory, GlueElement glueElement)
        {
            var gumStateCategory = new GumStateCategory();

            gumStateCategory.Name = glueStateCategory.Name;

            foreach (var glueState in glueStateCategory.States)
            {
                var gumState = ToGumState(glueState, glueElement);
                gumStateCategory.States.Add(gumState);
            }

            return(gumStateCategory);
        }
        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();
        }
示例#8
0
        public static StateSaveCategory GetStateCategoryRecursively(this IElement element, string stateCategoryName)
        {
            // start at the top-down
            StateSaveCategory category = element.GetStateCategory(stateCategoryName);

            if (category == null && !string.IsNullOrEmpty(element.BaseElement))
            {
                IElement baseElement = GlueState.CurrentGlueProject.GetElement(element.BaseElement);

                if (baseElement != null)
                {
                    return(baseElement.GetStateCategoryRecursively(stateCategoryName));
                }
            }


            return(category);
        }
        private void CreateEntitySaves()
        {
            mEntitySave = new EntitySave();
            mEntitySave.Name = "NamedObjectSaveTestsEntity";
            mEntitySave.ImplementsIVisible = true;
            mEntitySave.ImplementsIWindow = true;

            CustomVariable customVariable = new CustomVariable();
            customVariable.Type = "float";
            customVariable.Name = "X";

            mEntitySave.CustomVariables.Add(customVariable);

            customVariable = new CustomVariable();
            customVariable.Type = "float";
            customVariable.Name = "Y";
            customVariable.SetByDerived = true;
            mEntitySave.CustomVariables.Add(customVariable);

            StateSave stateSave = new StateSave();
            stateSave.Name = "TestState";
            mEntitySave.States.Add(stateSave);

            StateSaveCategory stateSaveCategory = new StateSaveCategory();
            stateSaveCategory.Name = "TestCategory";
            mEntitySave.StateCategoryList.Add(stateSaveCategory);

            StateSave categorizedState = new StateSave();
            categorizedState.Name = "CategorizedState";
            stateSaveCategory.States.Add(categorizedState);
            
            
            
            
            ObjectFinder.Self.GlueProject.Entities.Add(mEntitySave);


            mDerivedEntitySave = new EntitySave();
            mDerivedEntitySave.BaseEntity = mEntitySave.Name;
            mDerivedEntitySave.Name = "NamedObjectSaveTestDerivedEntity";
            ObjectFinder.Self.GlueProject.Entities.Add(mDerivedEntitySave);
        }
示例#10
0
        public void TestStateVariables()
        {
            EntitySave entitySave = new EntitySave();
            entitySave.Name = "CustomVariableTestStateVariableEntity";
            ObjectFinder.Self.GlueProject.Entities.Add(entitySave);

            StateSaveCategory category1 = new StateSaveCategory();
            category1.Name = "Category1";
            category1.SharesVariablesWithOtherCategories = false;
            StateSave stateSave = new StateSave();
            stateSave.Name = "Disabled";
            category1.States.Add(stateSave);

            StateSaveCategory category2 = new StateSaveCategory();
            category2.Name = "Category2";
            category2.SharesVariablesWithOtherCategories = false;
            stateSave = new StateSave();
            stateSave.Name = "Disabled";
            category2.States.Add(stateSave);

            entitySave.StateCategoryList.Add(category1);
            entitySave.StateCategoryList.Add(category2);

            CustomVariable customVariable = new CustomVariable();
            customVariable.Type = "Category2";
            customVariable.DefaultValue = "Disabled";
            customVariable.Name = "CurrentCategory2State";
            entitySave.CustomVariables.Add(customVariable);

            

            ElementRuntime elementRuntime = new ElementRuntime(entitySave, null, null, null, null);

            StateSave foundStateSave = 
                elementRuntime.GetStateSaveFromCustomVariableValue(customVariable, customVariable.DefaultValue);

            if (foundStateSave != category2.States[0])
            {
                throw new Exception("States in categories are not being found properly when referenced through custom variables");
            }

        }
示例#11
0
        public static bool IsStateNameValid(string name, IElement element, StateSaveCategory category, StateSave currentStateSave, out string whyItIsntValid)
        {
            whyItIsntValid = null;

            CheckForCommonImproperNames(name, ref whyItIsntValid);

            if (!string.IsNullOrEmpty(whyItIsntValid))
            {
                return(false);
            }

            //Check if shared
            if (element != null)
            {
                if (category == null || category.SharesVariablesWithOtherCategories)
                {
                    //Check states not in category
                    if (element.States.Any(otherState => otherState.Name == name && otherState != currentStateSave))
                    {
                        whyItIsntValid = "Conflicts with existing state";
                        return(false);
                    }

                    //Check categories that have sharing on
                    foreach (var stateSaveCategory in from stateSaveCategory in element.StateCategoryList
                             where stateSaveCategory.SharesVariablesWithOtherCategories
                             from stateSave in stateSaveCategory.States
                             where name == stateSave.Name && stateSave != currentStateSave
                             select stateSaveCategory)
                    {
                        whyItIsntValid = "Conflicts with existing state in category " + stateSaveCategory.Name;
                        return(false);
                    }
                }
                else if (category != null)
                {
                    if (category.States.Any(state => state.Name == name && state != currentStateSave))
                    {
                        whyItIsntValid = "The name " + name + " is already being used in the category " + category.Name;
                        return(false);
                    }
                }
            }

            if (!string.IsNullOrEmpty(element.BaseElement))
            {
                IElement baseElement = ObjectFinder.Self.GetIElement(element.BaseElement);

                if (baseElement != null)
                {
                    string categoryName = null;

                    if (category != null && category.SharesVariablesWithOtherCategories == false)
                    {
                        categoryName = category.Name;
                    }

                    if (baseElement.GetState(name, categoryName) != null)
                    {
                        string screenOrEntity = "screen";
                        if (baseElement is EntitySave)
                        {
                            screenOrEntity = "entity";
                        }

                        whyItIsntValid = "This state name \"" + name + "\" is already used in a base " + screenOrEntity;
                    }
                }
            }

            return(string.IsNullOrEmpty(whyItIsntValid));
        }
示例#12
0
 private void AddComboBoxIfStatesExist(StateSaveCategory category)
 {
     AddComboBoxIfStatesExist(category.Name, category.States);
 }
        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");
            }
        }
        static void AddStateCategoryClick(object sender, EventArgs e)
        {
            // add category, addcategory, add state category
            TextInputWindow tiw = new TextInputWindow();
            tiw.DisplayText = "Enter a name for the new category";
            tiw.Text = "New Category";

            DialogResult result = tiw.ShowDialog(MainGlueWindow.Self);

            if (result == DialogResult.OK)
            {
                string whyItIsntValid;

                if(!NameVerifier.IsStateCategoryNameValid(tiw.Result, out whyItIsntValid))
                {
                    GlueGui.ShowMessageBox(whyItIsntValid);
                }
                else
                {
                    IElement element = EditorLogic.CurrentElement;

                    StateSaveCategory newCategory = new StateSaveCategory();
                    newCategory.Name = tiw.Result;
                    newCategory.SharesVariablesWithOtherCategories = false;

                    element.StateCategoryList.Add(newCategory);

                    EditorLogic.CurrentElementTreeNode.UpdateReferencedTreeNodes();
                    ElementViewWindow.GenerateSelectedElementCode();

                    GluxCommands.Self.SaveGlux();
                    ProjectManager.SaveProjects();
                }
            }
        }
示例#15
0
        public static bool IsStateNameValid(string name, IElement element, StateSaveCategory category, StateSave currentStateSave, out string whyItIsntValid)
        {
            whyItIsntValid = null;

            CheckForCommonImproperNames(name, ref whyItIsntValid);

            if(!string.IsNullOrEmpty(whyItIsntValid))
                return false;

            //Check if shared
            if (element != null)
            {
                if (category == null || category.SharesVariablesWithOtherCategories)
                {
                    //Check states not in category
                    if (element.States.Any(otherState => otherState.Name == name && otherState != currentStateSave))
                    {
                        whyItIsntValid = "Conflicts with existing state";
                        return false;
                    }

                    //Check categories that have sharing on
                    foreach (var stateSaveCategory in from stateSaveCategory in element.StateCategoryList
                                                      where stateSaveCategory.SharesVariablesWithOtherCategories
                                                      from stateSave in stateSaveCategory.States
                                                      where name == stateSave.Name && stateSave != currentStateSave
                                                      select stateSaveCategory)
                    {
                        whyItIsntValid = "Conflicts with existing state in category " + stateSaveCategory.Name;
                        return false;
                    }
                }
                else if (category != null)
                {
                    if (category.States.Any(state => state.Name == name && state != currentStateSave))
                    {
                        whyItIsntValid = "The name " + name + " is already being used in the category " + category.Name;
                        return false;
                    }
                }
            }

            if (!string.IsNullOrEmpty(element.BaseElement))
            {
                IElement baseElement = ObjectFinder.Self.GetIElement(element.BaseElement);

                if (baseElement != null)
                {
                    string categoryName = null;

                    if (category != null && category.SharesVariablesWithOtherCategories == false)
                    {
                        categoryName = category.Name;
                    }

                    if (baseElement.GetState(name, categoryName) != null)
                    {
                        string screenOrEntity = "screen";
                        if(baseElement is EntitySave)
                        {
                            screenOrEntity = "entity";
                        }

                        whyItIsntValid = "This state name \"" + name + "\" is already used in a base " + screenOrEntity;
                    }

                    
                }

            }

            return string.IsNullOrEmpty(whyItIsntValid);
        }
        void CreateElementRuntime(string name)
        {
            var entitySave = new EntitySave {Name = name};

            ObjectFinder.Self.GlueProject.Entities.Add(entitySave);

            #region Create CustomVariables
            var xVariable = new CustomVariable
                                {
                                    Name = "X", 
                                    Type = "float", 
                                    DefaultValue = 3.0f
                                };
            entitySave.CustomVariables.Add(xVariable);

            var yVariable = new CustomVariable
                                {
                                    Name = "Y", 
                                    Type = "float", 
                                    DefaultValue = 4.0f
                                };
            entitySave.CustomVariables.Add(yVariable);


            var customVariable = new CustomVariable
                                {
                                    Name = "SomeNewVar",
                                    Type = "double",
                                    DefaultValue = 3.333
                                };
            entitySave.CustomVariables.Add(customVariable);

            var csvTypeVAriable = new CustomVariable
                                {
                                    Name = "CsvTypeVariable",
                                    Type = "CsvType.csv",
                                    DefaultValue = null

                                };
            entitySave.CustomVariables.Add(csvTypeVAriable);

            var csvTypeVariable2 = new CustomVariable
                                {
                                    Name = "EnemyInfoVariable",
                                    Type = "EnemyInfo.csv",
                                    DefaultValue = "Imp"

                                };
            entitySave.CustomVariables.Add(csvTypeVariable2);

            var scaleXVariable = new CustomVariable
            {
                Name = "ScaleX",
                Type = "float",
                DefaultValue = 10.0f
            };
            entitySave.CustomVariables.Add(scaleXVariable);


            #endregion

            #region Create the NamedObjectsSave

            NamedObjectSave nos = new NamedObjectSave();
            nos.SourceType = SourceType.FlatRedBallType;
            nos.SourceClassType = "Sprite";
            nos.InstanceName = "SpriteObject";
            nos.UpdateCustomProperties();
            nos.SetPropertyValue("ScaleX", 3.0f);
            entitySave.NamedObjects.Add(nos);


            #endregion

            #region Create the ReferencedFileSaves

            ReferencedFileSave rfs = new ReferencedFileSave();
            rfs.Name = "Content/Entities/ReferencedFileSaveTestsBaseEntity/SceneFile.scnx";
            entitySave.ReferencedFiles.Add(rfs);

            rfs = new ReferencedFileSave();
            rfs.Name = "Content/EnemyInfo.csv";
            rfs.CreatesDictionary = true;

            entitySave.ReferencedFiles.Add(rfs);


            #endregion

            mElementRuntime = new ElementRuntime(entitySave, null, null, null, null)
                                  {
                                      X = (float) xVariable.DefaultValue, 
                                      Y = (float) yVariable.DefaultValue
                                  };


            #region Create the uncategorized states

            var leftX = new InstructionSave
            {
                Member = "X",
                Value = -10,
                Type = "float"
            };




            var rightX = new InstructionSave
            {
                Member = "X",
                Value = 10,
                Type = "float"
            };

            var someNewVarSetLeft = new InstructionSave
            {
                Member = "SomeNewVar",
                Value = -10.0,
                Type = "double"

            };


            var someNewVarSetRight = new InstructionSave
            {
                Member = "SomeNewVar",
                Value = 10.0,
                Type = "double"

            };

            var leftState = new StateSave {Name = "Left"};
            leftState.InstructionSaves.Add(leftX);
            leftState.InstructionSaves.Add(someNewVarSetLeft);

            var rightState = new StateSave {Name = "Right"};
            rightState.InstructionSaves.Add(rightX);
            rightState.InstructionSaves.Add(someNewVarSetRight);


            entitySave.States.Add(leftState);
            entitySave.States.Add(rightState);

            #endregion

            #region Create the categorized states

            StateSaveCategory category = new StateSaveCategory();
            category.SharesVariablesWithOtherCategories = false;

            category.Name = "StateCategory";

            var topY = new InstructionSave
            {
                Member = "Y",
                Value = 10,
                Type = "float"
            };

            var bottomY = new InstructionSave
            {
                Member = "Y",
                Value = 10,
                Type = "float"
            };

            var topState = new StateSave { Name = "Top" };
            topState.InstructionSaves.Add(topY);
            var bottomState = new StateSave { Name = "Bottom" };
            bottomState.InstructionSaves.Add(rightX);

            category.States.Add(topState);
            category.States.Add(bottomState);

            entitySave.StateCategoryList.Add(category);

            #endregion
        }
        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;
        }
示例#18
0
 public void Add(string containerName, StateSaveCategory stateSaveCategory)
 {
     throw new NotImplementedException();
 }
示例#19
0
        public static void GetAdditionsNeededForChangingType(string oldType, string newType, List <PropertyValuePair> valuesToBeSet,
                                                             List <CustomVariable> neededVariables, List <StateSave> neededStates, List <StateSaveCategory> neededCategories)
        {
            IElement oldElement = ObjectFinder.Self.GetIElement(oldType);
            IElement newElement = ObjectFinder.Self.GetIElement(newType);

            if (oldElement != null && newElement != null)
            {
                #region Compare CustomVariables
                foreach (CustomVariable customVariable in oldElement.CustomVariables)
                {
                    string name = customVariable.Name;
                    string type = customVariable.Type;

                    // Is there a custom variable in the type to change to?
                    // We used to only call GetCustomVariable, but this needs
                    // to be recursive, because the object will get variables from
                    // the immediate type as well as all base types.
                    //CustomVariable customVariableInNewType = newElement.GetCustomVariable(name);
                    CustomVariable customVariableInNewType = newElement.GetCustomVariableRecursively(name);

                    if (customVariableInNewType == null || customVariableInNewType.Type != type)
                    {
                        neededVariables.Add(customVariable);
                    }
                }
                #endregion

                #region Compare interfaces like IClickable

                if (oldElement is EntitySave && newElement is EntitySave)
                {
                    EntitySave oldEntity = oldElement as EntitySave;
                    EntitySave newEntity = newElement as EntitySave;

                    if (oldEntity.GetImplementsIClickableRecursively() && !newEntity.GetImplementsIClickableRecursively())
                    {
                        valuesToBeSet.Add(new PropertyValuePair("ImplementsIClickable", true));
                    }
                    if (oldEntity.GetImplementsIVisibleRecursively() && !newEntity.GetImplementsIVisibleRecursively())
                    {
                        valuesToBeSet.Add(new PropertyValuePair("ImplementsIVisible", true));
                    }
                    if (oldEntity.GetImplementsIWindowRecursively() && !newEntity.GetImplementsIWindowRecursively())
                    {
                        valuesToBeSet.Add(new PropertyValuePair("ImplementsIWindow", true));
                    }
                }

                #endregion

                #region Compare States

                // Don't use AllStates because we want
                // states that belong to categories to be
                // identified as being in categories.
                foreach (StateSave state in oldElement.States)
                {
                    if (newElement.GetUncategorizedStateRecursively(state.Name) == null)
                    {
                        neededStates.Add(state);
                    }
                }

                #endregion

                #region Compare Categories

                foreach (StateSaveCategory category in oldElement.StateCategoryList)
                {
                    StateSaveCategory cloneOfCategory = null;
                    StateSaveCategory categoryInNew   = newElement.GetStateCategoryRecursively(category.Name);
                    if (categoryInNew == null)
                    {
                        cloneOfCategory = new StateSaveCategory {
                            Name = category.Name
                        };
                        neededCategories.Add(cloneOfCategory);
                    }

                    List <StateSave> statesMissingInNewCategory = new List <StateSave>();

                    foreach (StateSave state in category.States)
                    {
                        if (categoryInNew == null || categoryInNew.GetState(state.Name) == null)
                        {
                            if (cloneOfCategory == null)
                            {
                                cloneOfCategory = new StateSaveCategory {
                                    Name = category.Name
                                };
                            }
                            cloneOfCategory.States.Add(state);
                        }
                    }

                    if (cloneOfCategory != null)
                    {
                        neededCategories.Add(cloneOfCategory);
                    }
                }


                #endregion
            }
        }
        public static void GetAdditionsNeededForChangingType(string oldType, string newType, List<PropertyValuePair> valuesToBeSet,
            List<CustomVariable> neededVariables, List<StateSave> neededStates, List<StateSaveCategory> neededCategories)
        {
            IElement oldElement = ObjectFinder.Self.GetIElement(oldType);
            IElement newElement = ObjectFinder.Self.GetIElement(newType);

            if (oldElement != null && newElement != null)
            {
                #region Compare CustomVariables
                foreach (CustomVariable customVariable in oldElement.CustomVariables)
                {
                    string name = customVariable.Name;
                    string type = customVariable.Type;

                    // Is there a custom variable in the type to change to?
                    // We used to only call GetCustomVariable, but this needs
                    // to be recursive, because the object will get variables from
                    // the immediate type as well as all base types.
                    //CustomVariable customVariableInNewType = newElement.GetCustomVariable(name);
                    CustomVariable customVariableInNewType = newElement.GetCustomVariableRecursively(name);
                    
                    if (customVariableInNewType == null || customVariableInNewType.Type != type)
                    {
                        neededVariables.Add(customVariable);
                    }
                }
                #endregion

                #region Compare interfaces like IClickable

                if (oldElement is EntitySave && newElement is EntitySave)
                {
                    EntitySave oldEntity = oldElement as EntitySave;
                    EntitySave newEntity = newElement as EntitySave;

                    if (oldEntity.GetImplementsIClickableRecursively() && !newEntity.GetImplementsIClickableRecursively())
                    {
                        valuesToBeSet.Add(new PropertyValuePair("ImplementsIClickable", true));
                    }
                    if (oldEntity.GetImplementsIVisibleRecursively() && !newEntity.GetImplementsIVisibleRecursively())
                    {
                        valuesToBeSet.Add(new PropertyValuePair("ImplementsIVisible", true));
                    }
                    if (oldEntity.GetImplementsIWindowRecursively() && !newEntity.GetImplementsIWindowRecursively())
                    {
                        valuesToBeSet.Add(new PropertyValuePair("ImplementsIWindow", true));
                    }
                }

                #endregion

                #region Compare States

                // Don't use AllStates because we want
                // states that belong to categories to be
                // identified as being in categories.
                foreach (StateSave state in oldElement.States)
                {
                    if (newElement.GetUncategorizedStateRecursively(state.Name) == null)
                    {
                        neededStates.Add(state);
                    }
                }

                #endregion

                #region Compare Categories

                foreach (StateSaveCategory category in oldElement.StateCategoryList)
                {
                    StateSaveCategory cloneOfCategory = null;
                    StateSaveCategory categoryInNew = newElement.GetStateCategoryRecursively(category.Name);
                    if (categoryInNew == null)
                    {
                        cloneOfCategory = new StateSaveCategory { Name = category.Name };
                        neededCategories.Add(cloneOfCategory);
                    }

                    List<StateSave> statesMissingInNewCategory = new List<StateSave>();

                    foreach (StateSave state in category.States)
                    {
                        if (categoryInNew == null || categoryInNew.GetState(state.Name) == null)
                        {
                            if (cloneOfCategory == null)
                            {
                                cloneOfCategory = new StateSaveCategory { Name = category.Name };
                            }
                            cloneOfCategory.States.Add(state);
                        }
                    }

                    if (cloneOfCategory != null)
                    {
                        neededCategories.Add(cloneOfCategory);
                    }

                }


                #endregion
            }
        }
示例#21
0
        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;
        }
        private static void ReactToStateNameChange(object oldValue, StateSave stateSave, StateSaveCategory category, IElement parentObject)
        {
            PluginManager.ReactToStateNameChange(parentObject as IElement, (string)oldValue, stateSave.Name);


            IElement parentAsElement = parentObject as IElement;

            string name = parentObject.Name;

            string typeToMatch = "VariableState";
            if (category != null && category.SharesVariablesWithOtherCategories == false)
            {
                typeToMatch = "Current" + category.Name + "State";
            }

            var matchingVariables = from variable in parentAsElement.CustomVariables
                                    where variable.DefaultValue == oldValue &&
                                    variable.Type == typeToMatch
                                    select variable;

            foreach (CustomVariable variable in matchingVariables)
            {
                variable.DefaultValue = stateSave.Name;
            }

            string variableName = stateSave.GetExposedVariableName(parentObject);
            string variableType = stateSave.GetEnumTypeName(parentObject);

            // Find any NOSs that use the ParentObject as their type
            foreach (ScreenSave screenSave in ObjectFinder.Self.GlueProject.Screens)
            {
                var customQuery = from nos in screenSave.AllNamedObjects
                                    where nos.SourceType == SourceType.Entity &&
                                    nos.SourceClassType == name
                                    select nos;

                foreach (var nos in customQuery)
                {
                    if (nos.CurrentState == (oldValue as string))
                    {
                        nos.CurrentState = stateSave.Name;
                    }
                    foreach (var variable in nos.InstructionSaves.Where(item => item.Member == variableName && (item.Value as string) == (oldValue as string)))
                    {
                        variable.Value = stateSave.Name;
                    }
                }
            }

            foreach (EntitySave entitySave in ObjectFinder.Self.GlueProject.Entities)
            {
                var customQuery = from nos in entitySave.AllNamedObjects
                                    where nos.SourceType == SourceType.Entity &&
                                    nos.SourceClassType == name
                                    select nos;

                foreach (var nos in customQuery)
                {
                    if (nos.CurrentState == (oldValue as string))
                    {

                        nos.CurrentState = stateSave.Name;
                    }
                    foreach (var variable in nos.InstructionSaves.Where(item => item.Member == variableName && (item.Value as string) == (oldValue as string)))
                    {
                        variable.Value = stateSave.Name;
                    }
                }
            }
        }
 private void UpdateIncludedAndExcluded(StateSaveCategory category)
 {
     ExcludeMember("States");
 }
示例#24
0
        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();
        }
示例#25
0
        void CreateElementRuntime()
        {
            mEntitySave = new EntitySave { Name = "VariableSettingEntity" };

            ObjectFinder.Self.GlueProject.Entities.Add(mEntitySave);
            
            var xVariable = new CustomVariable
            {
                Name = "X",
                Type = "float",
                DefaultValue = 0
            };
            mEntitySave.CustomVariables.Add(xVariable);

            // Needs the Z variable exposed so that the uncategorized state below can use it:
            var zVariable = new CustomVariable
            {
                Name = "Z",
                Type = "float",
                DefaultValue = 0
            };
            mEntitySave.CustomVariables.Add(zVariable);

            CustomVariable stateVariable = new CustomVariable
            {
                Name = "CurrentStateSaveCategoryState",
                Type = "StateSaveCategory",
                DefaultValue = "FirstState"
            };
            stateVariable.SetByDerived = true;
            mEntitySave.CustomVariables.Add(stateVariable);


            CustomVariable uncategorizedStateVariable = new CustomVariable
            {
                Name = "CurrentState",
                Type = "VariableState",
                //DefaultValue = "Uncategorized", // Don't set a default value - the derived will do this
                SetByDerived = true
            };
            mEntitySave.CustomVariables.Add(uncategorizedStateVariable);




            StateSave uncategorized = new StateSave();
            uncategorized.Name = "Uncategorized";
            InstructionSave instruction = new InstructionSave();
            instruction.Member = "Z";
            instruction.Value = 8.0f;
            uncategorized.InstructionSaves.Add(instruction);
            mEntitySave.States.Add(uncategorized);
            
            StateSave stateSave = new StateSave();
            stateSave.Name = "FirstState";
            instruction = new InstructionSave();
            instruction.Member = "X";
            instruction.Value = 10;
            stateSave.InstructionSaves.Add(instruction);

            StateSave secondStateSave = new StateSave();
            secondStateSave.Name = "SecondState";
            instruction = new InstructionSave();
            instruction.Member = "X";
            instruction.Value = -10;
            secondStateSave.InstructionSaves.Add(instruction);


            StateSaveCategory category = new StateSaveCategory();
            category.Name = "StateSaveCategory";
            category.States.Add(stateSave);
            category.States.Add(secondStateSave);

            mEntitySave.StateCategoryList.Add(category);
            mElementRuntime = new ElementRuntime(mEntitySave, null, null, null, null);
            mElementRuntime.AfterVariableApply += AfterVariableSet;



        }
示例#26
0
        public TreeNode StateCategoryTreeNode(StateSaveCategory category)
        {
            TreeNode treeNode = TreeNodeByTagIn(category, ElementViewWindow.ScreensTreeNode.Nodes);

            if (treeNode == null)
            {
                treeNode = TreeNodeByTagIn(category, ElementViewWindow.EntitiesTreeNode.Nodes);
            }

            return treeNode;

        }
示例#27
0
        private void CreateEntitySave()
        {
            mEntitySave = ExposedVariableTests.CreateEntitySaveWithStates("StateEntity");
            ObjectFinder.Self.GlueProject.Entities.Add(mEntitySave);

            mExposedStateVariable = new CustomVariable();
            mExposedStateVariable.Name = "CurrentState";
            mExposedStateVariable.Type = "VariableState";
            mExposedStateVariable.SetByDerived = true;
            mEntitySave.CustomVariables.Add(mExposedStateVariable);

            mExposedStateInCategoryVariable = new CustomVariable();
            mExposedStateInCategoryVariable.Name = "CurrentStateCategoryState";
            mExposedStateInCategoryVariable.Type = "StateCategory";
            mExposedStateInCategoryVariable.SetByDerived = true;
            mEntitySave.CustomVariables.Add(mExposedStateInCategoryVariable);

            mRenamedExposedUncategorizedStateVariable = new CustomVariable();
            mRenamedExposedUncategorizedStateVariable.Name = "RenamedVariable";
            mRenamedExposedUncategorizedStateVariable.Type = "VariableState";
            mRenamedExposedUncategorizedStateVariable.SetByDerived = true;
            mEntitySave.CustomVariables.Add(mRenamedExposedUncategorizedStateVariable);

            mRenamedExposedCategorizedStateVariable = new CustomVariable();
            mRenamedExposedCategorizedStateVariable.Name = "RenamedCategorizedVariable";
            mRenamedExposedCategorizedStateVariable.Type = "StateCategory";
            mEntitySave.CustomVariables.Add(mRenamedExposedCategorizedStateVariable);

            // Let's add some states now
            StateSave stateSave = new StateSave();
            stateSave.Name = "FirstState";
            mEntitySave.States.Add(stateSave);

            stateSave = new StateSave();
            stateSave.Name = "SecondState";
            mEntitySave.States.Add(stateSave);

            StateSaveCategory category = new StateSaveCategory();
            category.Name = "SharedVariableCategory";
            mEntitySave.StateCategoryList.Add(category);

            stateSave = new StateSave();
            stateSave.Name = "SharedStateSave";
            category.States.Add(stateSave);

        }