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; } }
public RecursiveVariableFinder(StateSave stateSave) { ContainerType = VariableContainerType.StateSave; mStateSave = stateSave; mElementStack = new List <ElementWithState>(); #if DEBUG if (stateSave.ParentContainer == null) { throw new NullReferenceException("The state passed in to the RecursiveVariableFinder has a null ParentContainer and it shouldn't"); } #endif mElementStack.Add(new ElementWithState(stateSave.ParentContainer) { StateName = stateSave.Name }); }
public static UndoObject CreateUndoObject(StateSave objectToSave, List<InstanceSave> instances, object parent) { StateSave cloned = FileManager.CloneSaveObject(objectToSave); List<InstanceSave> instancesCloned = null; if (instances != null) { instancesCloned = new List<InstanceSave>(); foreach (var instance in instances) { instancesCloned.Add(instance); // no need to clone this, I don't think } } UndoObject undoObject = new UndoObject( cloned, instancesCloned, parent); return undoObject; }
private static void FixStateVariableTypes(ElementSave elementSave, StateSave state, ref bool wasModified) { foreach (var variable in state.Variables.Where(item => item.Type == "string" && item.Name.Contains("State"))) { string name = variable.Name; var withoutState = name.Substring(0, name.Length - "State".Length); if (variable.Name == "State") { variable.Type = "State"; wasModified = true; } else if (elementSave.Categories.Any(item => item.Name == withoutState)) { variable.Type = withoutState; wasModified = true; } } }
private static void RemoveDuplicateVariables(StateSave state) { List <string> alreadyVisitedVariables = new List <string>(); for (int i = 0; i < state.Variables.Count; i++) { string variableName = state.Variables[i].Name; if (alreadyVisitedVariables.Contains(variableName)) { state.Variables.RemoveAt(i); i--; } else { alreadyVisitedVariables.Add(variableName); } } }
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"); } }
public static UndoObject CreateUndoObject(StateSave objectToSave, List <InstanceSave> instances, object parent) { StateSave cloned = FileManager.CloneSaveObject(objectToSave); List <InstanceSave> instancesCloned = null; if (instances != null) { instancesCloned = new List <InstanceSave>(); foreach (var instance in instances) { instancesCloned.Add(instance); // no need to clone this, I don't think } } UndoObject undoObject = new UndoObject( cloned, instancesCloned, parent); return(undoObject); }
public void SetValue(object component, object value) { ElementSave elementSave = SelectedState.Self.SelectedElement; StateSave stateSave = SelectedState.Self.SelectedStateSave; InstanceSave instanceSave = SelectedState.Self.SelectedInstance; //////////////// Early Out///////////// if (stateSave == null || elementSave == null) { return; } ///////////////End Early Out/////////// string name = GetVariableNameConsideringSelection(); // <None> is a reserved // value for when we want // to allow the user to reset // a value through a combo box. // If the value is "<None>" then // let's set it to null if (value is string && ((string)value) == "<None>") { value = null; } string variableType = null; var existingVariable = elementSave.GetVariableFromThisOrBase(name); if (existingVariable != null) { variableType = existingVariable.Type; } stateSave.SetValue(name, value, instanceSave, variableType); }
private void PastedCopiedState() { ElementSave container = SelectedState.Self.SelectedElement; /////////////////////Early Out////////////////// if (container == null) { return; } //////////////////End Early Out//////////////// if (container.Categories.Count != 0) { MessageBox.Show("Pasting into elements with state categories may cause unexpected results. Please complain on codeplex!"); } StateSave newStateSave = mCopiedState.Clone(); newStateSave.Variables.RemoveAll(item => item.CanOnlyBeSetInDefaultState); newStateSave.ParentContainer = container; string name = mCopiedState.Name + "Copy"; name = StringFunctions.MakeStringUnique(name, container.States.Select(item => item.Name)); newStateSave.Name = name; container.States.Add(newStateSave); StateTreeViewManager.Self.RefreshUI(container); //SelectedState.Self.SelectedInstance = targetInstance; SelectedState.Self.SelectedStateSave = newStateSave; GumCommands.Self.FileCommands.TryAutoSaveElement(container); }
public override System.ComponentModel.PropertyDescriptorCollection GetProperties(Attribute[] attributes) { PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(this, true); StateSave stateSave = SelectedState.Self.SelectedStateSave; ElementSave elementSave = SelectedState.Self.SelectedElement; InstanceSave instanceSave = SelectedState.Self.SelectedInstance; if (instanceSave != null && stateSave != null) { pdc = DisplayCurrentInstance(pdc, instanceSave); } else if (elementSave != null && stateSave != null) { pdc = DisplayCurrentElement(pdc, elementSave, null, elementSave.States[0], null); } return(pdc); }
public StateViewModel(StateSave state, StateSaveCategory category, IElement element) { this.category = category; this.element = element; BackingData = state; Variables = new ObservableCollection <object>(); 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); this.Variables.Add(instruction?.Value); } }
private static void FillWithDefaultRecursively(ElementSave element, StateSave stateSave) { foreach (var variable in element.DefaultState.Variables) { var alreadyExists = stateSave.Variables.Any(item => item.Name == variable.Name); if (!alreadyExists) { stateSave.Variables.Add(variable); } } if (!string.IsNullOrEmpty(element.BaseType)) { var baseElement = ObjectFinder.Self.GetElementSave(element.BaseType); if (baseElement != null) { FillWithDefaultRecursively(baseElement, stateSave); } } }
private List <MemberCategory> GetMemberCategories(ElementSave element, StateSave state, StateSaveCategory stateCategory, InstanceSave instance) { List <MemberCategory> categories = new List <MemberCategory>(); mLastElement = element; mLastState = state; mLastInstance = instance; mLastCategory = stateCategory; var stateSave = SelectedState.Self.SelectedStateSave; if (stateSave != null) { GetMemberCategoriesForState(element, instance, categories, stateSave, stateCategory); } else if (stateCategory != null) { GetMemberCategoriesForStateCategory(element, instance, categories, stateCategory); } return(categories); }
public void Deserialize(ScriptData instance, StateSave save) { instance.State = save.State; instance.Running = save.Running; instance.EventDelayTicks = (long)save.MinEventDelay; instance.AssemblyName = save.AssemblyName; instance.Disabled = save.Disabled; instance.UserInventoryItemID = save.UserInventoryID; instance.PluginData = save.Plugins; instance.Source = save.Source; instance.InventoryItem.PermsGranter = save.PermsGranter; instance.InventoryItem.PermsMask = save.PermsMask; instance.TargetOmegaWasSet = save.TargetOmegaWasSet; Dictionary <string, object> vars = WebUtils.ParseXmlResponse(save.Variables); if (vars != null && vars.Count != 0 || instance.Script != null) { instance.Script.SetStoreVars(vars); } }
bool GetIfCanMoveUp(StateSave state, StateSaveCategory category) { var list = SelectedState.Self.SelectedElement.States; if (category != null) { list = category.States; } int stateIndex = list.IndexOf(state); int indexToBeGreaterThan = 0; if (category == null) { // Uncategorized, so it can't move up above the Default state indexToBeGreaterThan = 1; } return(stateIndex > indexToBeGreaterThan); }
private void HandlePropertyOnStateChanged(object sender, PropertyChangedEventArgs e) { if (e.PropertyName == nameof(StateViewModel.Name)) { StateViewModel selectedViewModel = sender as StateViewModel; StateSave stateSave = selectedViewModel.BackingData; var needsToCreateNewState = selectedViewModel.BackingData == null && !string.IsNullOrEmpty(selectedViewModel.Name) && selectedViewModel.IsNameInvalid == false; if (needsToCreateNewState) { stateSave = new StateSave(); stateSave.Name = selectedViewModel.Name; var category = GlueState.Self.CurrentStateSaveCategory; category.States.Add(stateSave); selectedViewModel.BackingData = stateSave; // Add a new entry so the user can create more states easily: CreateBlankViewModelAtEnd(GlueState.Self.CurrentElement); CopyViewModelValuesToState(selectedViewModel, stateSave); } if (selectedViewModel.IsNameInvalid == false) { stateSave.Name = selectedViewModel.Name; GlueCommands.Self.GenerateCodeCommands.GenerateAllCodeTask(); GlueCommands.Self.GluxCommands.SaveGluxTask(); } GlueCommands.Self.RefreshCommands.RefreshUi(this.category); if (string.IsNullOrEmpty(selectedViewModel.Name)) { CheckForStateRemoval(selectedViewModel); } } }
public void ApplyValueToModel(object value, StateViewModel stateViewModel, StateSave stateSave, CustomVariable variable) { if (value == null || value as string == String.Empty) { var existingInstruction = stateSave?.InstructionSaves.FirstOrDefault(item => item.Member == variable.Name); if (existingInstruction != null) { stateSave.InstructionSaves.Remove(existingInstruction); } CheckForStateRemoval(stateViewModel); } else { try { var convertedValue = Convert(value, variable); // This could have converted incorrectly. if (convertedValue != null) { stateSave.SetValue(variable.Name, convertedValue); } else { var existingInstruction = stateSave?.InstructionSaves.FirstOrDefault(item => item.Member == variable.Name); if (existingInstruction != null) { stateSave.InstructionSaves.Remove(existingInstruction); } } } catch (Exception e) { GlueCommands.Self.PrintError( $"Could not assign variable {variable.Name} ({variable.Type}) to \"{value}\":\n{e.ToString()}"); } } }
public static void AddDimensionsVariables(StateSave stateSave, float defaultWidth, float defaultHeight, DimensionVariableAction dimensionVariableAction) { stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = defaultWidth, Name = "Width", Category = "Dimensions" }); var defaultValue = DimensionUnitType.Absolute; if (dimensionVariableAction == DimensionVariableAction.DefaultToPercentageOfFile) { defaultValue = DimensionUnitType.PercentageOfSourceFile; } VariableSave variableSave = new VariableSave { SetsValue = true, Type = typeof(DimensionUnitType).Name, Value = defaultValue, Name = "Width Units", Category = "Dimensions" }; if (dimensionVariableAction == DimensionVariableAction.ExcludeFileOptions) { variableSave.ExcludedValuesForEnum.Add(DimensionUnitType.PercentageOfSourceFile); variableSave.ExcludedValuesForEnum.Add(DimensionUnitType.MaintainFileAspectRatio); } stateSave.Variables.Add(variableSave); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = defaultHeight, Name = "Height", Category = "Dimensions" }); variableSave = new VariableSave { SetsValue = true, Type = typeof(DimensionUnitType).Name, Value = defaultValue, Name = "Height Units", Category = "Dimensions" }; if (dimensionVariableAction == DimensionVariableAction.ExcludeFileOptions) { variableSave.ExcludedValuesForEnum.Add(DimensionUnitType.PercentageOfSourceFile); variableSave.ExcludedValuesForEnum.Add(DimensionUnitType.MaintainFileAspectRatio); } stateSave.Variables.Add(variableSave); }
private void HandleElementBaseType(ElementSave asElementSave) { string newValue = asElementSave.BaseType; // kill the old instances: asElementSave.Instances.RemoveAll(item => item.DefinedByBase); if (StandardElementsManager.Self.IsDefaultType(newValue)) { StateSave defaultStateSave = StandardElementsManager.Self.GetDefaultStateFor(newValue); asElementSave.Initialize(defaultStateSave); } else { var baseElement = ObjectFinder.Self.GetElementSave(asElementSave.BaseType); StateSave stateSave = new StateSave(); if (baseElement != null) { // This copies the values to this explicitly, which we don't want //FillWithDefaultRecursively(baseElement, stateSave); foreach (var instance in baseElement.Instances) { var derivedInstance = instance.Clone(); derivedInstance.DefinedByBase = true; asElementSave.Instances.Add(derivedInstance); } asElementSave.Initialize(stateSave); } } const bool fullRefresh = true; // since the type might change: GumCommands.Self.GuiCommands.RefreshElementTreeView(asElementSave); PropertyGridManager.Self.RefreshUI(fullRefresh); StateTreeViewManager.Self.RefreshUI(asElementSave); }
public void ReactToStateSaveChangedValue(StateSave stateSave, StateSaveCategory category, string changedMember, object oldValue, IElement parentObject, ref bool updateTreeView) { if (changedMember != "Name") { updateTreeView = false; } 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); } } }
public static object GetValueFromThisOrBase(this ElementSave element, string variable, bool forceDefault = false) { StateSave stateToPullFrom = element.DefaultState; #if GUM if (element == SelectedState.Self.SelectedElement && SelectedState.Self.SelectedStateSave != null && !forceDefault) { stateToPullFrom = SelectedState.Self.SelectedStateSave; } #endif VariableSave variableSave = stateToPullFrom.GetVariableRecursive(variable); if (variableSave != null) { return(variableSave.Value); } else { return(null); } }
public object GetValue(string variableName) { StateSave stateSave = Instance as StateSave; foreach (InstructionSave instructionSave in stateSave.InstructionSaves) { if (instructionSave.Member == variableName) { return(instructionSave.Value); } } //NamedObjectPropertyOverride propertyOverride = stateSave.GetNamedObjectOverride(variableName); //if (propertyOverride != null) //{ // return propertyOverride; //} //else //{ // IElement element = ObjectFinder.Self.GetElementContaining(stateSave); // if (element != null) // { // NamedObjectSave namedObject = element.GetNamedObjectRecursively(variableName); // if (namedObject != null) // { // propertyOverride = new NamedObjectPropertyOverride(); // propertyOverride.Name = variableName; // return propertyOverride; // } // } //} return(null); }
public StateSave FindScriptStateSave(ScriptData script) { OSDMap component = m_manager.GetComponentState(script.Part, m_componentName) as OSDMap; //Attempt to find the state saves we have if (component != null) { OSD o; //If we have one for this item, deserialize it if (!component.TryGetValue(script.ItemID.ToString(), out o)) { if (!component.TryGetValue(script.InventoryItem.OldItemID.ToString(), out o)) { return(null); } } StateSave save = new StateSave(); save.FromOSD((OSDMap)o); return(save); } return(null); }
private static StateSave GetRecursiveStateFor(ElementSave elementSave, StateSave stateToAddTo = null) { // go bottom up var baseElement = ObjectFinder.Self.GetElementSave(elementSave.BaseType); if (baseElement != null) { stateToAddTo = GetRecursiveStateFor(baseElement, stateToAddTo); } if (stateToAddTo == null) { stateToAddTo = new StateSave(); } var existingVariableNames = stateToAddTo.Variables.Select(item => item.Name); if (elementSave is StandardElementSave) { var defaultStates = StandardElementsManager.Self.GetDefaultStateFor(elementSave.Name); var variablesToAdd = defaultStates.Variables .Select(item => item.Clone()) .Where(item => existingVariableNames.Contains(item.Name) == false); stateToAddTo.Variables.AddRange(variablesToAdd); } else { var variablesToAdd = elementSave.DefaultState.Variables .Select(item => item.Clone()) .Where(item => existingVariableNames.Contains(item.Name) == false); stateToAddTo.Variables.AddRange(variablesToAdd); } return(stateToAddTo); }
public void SaveStateTo(ScriptData script) { StateSave stateSave = new StateSave(); stateSave.State = script.State; stateSave.ItemID = script.ItemID; stateSave.Running = script.Running; stateSave.MinEventDelay = script.EventDelayTicks; stateSave.Disabled = script.Disabled; stateSave.UserInventoryID = script.UserInventoryItemID; //Allow for the full path to be put down, not just the assembly name itself stateSave.AssemblyName = script.AssemblyName; stateSave.Source = script.Source; if (script.InventoryItem != null) { stateSave.PermsGranter = script.InventoryItem.PermsGranter; stateSave.PermsMask = script.InventoryItem.PermsMask; } else { stateSave.PermsGranter = UUID.Zero; stateSave.PermsMask = 0; } stateSave.TargetOmegaWasSet = script.TargetOmegaWasSet; //Vars Dictionary <string, Object> vars = new Dictionary <string, object> (); if (script.Script != null) { vars = script.Script.GetStoreVars(); } stateSave.Variables = WebUtils.BuildXmlResponse(vars); //Plugins stateSave.Plugins = m_module.GetSerializationData(script.ItemID, script.Part.UUID); CreateOSDMapForState(script, stateSave); }
public void InterpolateToRatio(float ratio, bool isLevelUp) { var currentRatio = Bar.Height / MaxHeight; var currentState = new StateSave(); currentState.SetValue(nameof(Bar.Height), Bar.Height, "float"); float newHeight; if (!isLevelUp) { newHeight = ratio * MaxHeight; } else { newHeight = MaxHeight; } var newState = new StateSave(); newState.SetValue(nameof(Bar.Height), newHeight, "float"); Bar.InterpolateTo(currentState, newState, 1, FlatRedBall.Glue.StateInterpolation.InterpolationType.Exponential, FlatRedBall.Glue.StateInterpolation.Easing.Out); if (isLevelUp) { CurrentScreen.Call(() => { Bar.Height = 0; if (ratio > 0) { InterpolateToRatio(ratio, false); } }) .After(1.1f); } }
internal void RenameState(StateSave stateSave, IStateContainer stateContainer) { var behaviorNeedingState = GetBehaviorsNeedingState(stateSave); if (behaviorNeedingState.Any()) { string message = "This state cannot be removed because it is needed by the following behavior(s):"; foreach (var behavior in behaviorNeedingState) { message += "\n" + behavior.Name; } MessageBox.Show(message); } else { TextInputWindow tiw = new TextInputWindow(); tiw.Message = "Enter new state name"; tiw.Result = SelectedState.Self.SelectedStateSave.Name; var result = tiw.ShowDialog(); if (result == DialogResult.OK) { string oldName = stateSave.Name; stateSave.Name = tiw.Result; GumCommands.Self.GuiCommands.RefreshStateTreeView(); // I don't think we need to save the project when renaming a state: //GumCommands.Self.FileCommands.TryAutoSaveProject(); PluginManager.Self.StateRename(stateSave, oldName); GumCommands.Self.FileCommands.TryAutoSaveCurrentElement(); } } }
private static void DuplicateStateClick() { // Is there a "custom" current state save, like an interpolation or animation? if (SelectedState.Self.CustomCurrentStateSave != null) { GumCommands.Self.GuiCommands.ShowMessage("Cannot duplicate state while a custom state is displaying. Are you creating or playing animations?"); return; } ////////End Early Out/////////////// StateSave newState = SelectedState.Self.SelectedStateSave.Clone(); newState.ParentContainer = SelectedState.Self.SelectedElement; if (SelectedState.Self.SelectedStateCategorySave == null) { int index = SelectedState.Self.SelectedElement.States.IndexOf(SelectedState.Self.SelectedStateSave); SelectedState.Self.SelectedElement.States.Insert(index + 1, newState); } else { int index = SelectedState.Self.SelectedStateCategorySave.States.IndexOf(SelectedState.Self.SelectedStateSave); SelectedState.Self.SelectedStateCategorySave.States.Insert(index + 1, newState); } while (SelectedState.Self.SelectedStateContainer.AllStates.Any(item => item != newState && item.Name == newState.Name)) { newState.Name = StringFunctions.IncrementNumberAtEnd(newState.Name); } StateTreeViewManager.Self.RefreshUI(SelectedState.Self.SelectedElement); SelectedState.Self.SelectedStateSave = newState; GumCommands.Self.FileCommands.TryAutoSaveCurrentElement(); }
private static void StoreCopiedInstances() { if (SelectedState.Self.SelectedInstance != null) { var element = SelectedState.Self.SelectedElement; List <InstanceSave> selected = new List <InstanceSave>(); // When copying we want to grab all instances in the order that they are in their container. // That way when they're pasted they are pasted in the right order foreach (var instance in SelectedState.Self.SelectedInstances.OrderBy(item => element.Instances.IndexOf(item))) { selected.Add(instance.Clone()); } mCopiedInstances = GetAllInstancesAndChildrenOf(selected, selected.FirstOrDefault()?.ParentContainer); mCopiedState = SelectedState.Self.SelectedStateSave?.Clone() ?? SelectedState.Self.SelectedElement.DefaultState.Clone(); // Clear out any variables that don't pertain to the selected instance: for (int i = mCopiedState.Variables.Count - 1; i > -1; i--) { if (mCopiedInstances.Any(item => item.Name == mCopiedState.Variables[i].SourceObject) == false) { mCopiedState.Variables.RemoveAt(i); } } // And also any VariableLists: for (int i = mCopiedState.VariableLists.Count - 1; i > -1; i--) { if (mCopiedInstances.Any(item => item.Name == mCopiedState.VariableLists[i].SourceObject) == false) { mCopiedState.VariableLists.RemoveAt(i); } } } }
public List <InstanceSavePropertyDescriptor> GetProperties(Attribute[] attributes) { // search terms: display properties, display variables, show variables, variable display, variable displayer List <InstanceSavePropertyDescriptor> pdc = new List <InstanceSavePropertyDescriptor>(); StateSave stateSave = SelectedState.Self.SelectedStateSave; ElementSave elementSave = SelectedState.Self.SelectedElement; InstanceSave instanceSave = SelectedState.Self.SelectedInstance; if (instanceSave != null && stateSave != null) { DisplayCurrentInstance(pdc, instanceSave); } else if (elementSave != null && stateSave != null) { StateSave defaultState = GetRecursiveStateFor(elementSave); DisplayCurrentElement(pdc, elementSave, null, defaultState, null); } return(pdc); }
private static void MakeDefaultClick() { StateSave state = SelectedState.Self.SelectedStateSave; var element = SelectedState.Self.SelectedElement; if (!element.States.Contains(state)) { // It's categorized MessageBox.Show("Categorized states cannot be made default"); } else { element.States.Remove(state); element.States.Insert(0, state); StateTreeViewManager.Self.RefreshUI(SelectedState.Self.SelectedElement); SelectedState.Self.SelectedStateSave = state; GumCommands.Self.FileCommands.TryAutoSaveCurrentElement(); } }
public void PasteInstanceSaves(List <InstanceSave> copiedInstances, StateSave copiedState, ElementSave targetElement) { List <InstanceSave> newInstances = new List <InstanceSave>(); foreach (var instanceAsObject in copiedInstances) { InstanceSave sourceInstance = instanceAsObject as InstanceSave; ElementSave sourceElement = sourceInstance.ParentContainer; InstanceSave targetInstance = sourceInstance.Clone(); newInstances.Add(targetInstance); if (targetElement != null) { PastedCopiedInstance(sourceInstance, sourceElement, targetElement, targetInstance, copiedState); } } if (newInstances.Count > 1) { SelectedState.Self.SelectedInstances = newInstances; } }
public void RemoveState(StateSave stateSave, ElementSave elementToRemoveFrom) { elementToRemoveFrom.States.Remove(stateSave); foreach (var category in elementToRemoveFrom.Categories.Where(item => item.States.Contains(stateSave))) { category.States.Remove(stateSave); } GumCommands.Self.FileCommands.TryAutoSaveCurrentElement(); }
private static void AddPositioningVariables(StateSave stateSave) { List<object> xUnitsExclusions = new List<object>(); xUnitsExclusions.Add(PositionUnitType.PixelsFromTop); xUnitsExclusions.Add(PositionUnitType.PercentageHeight); xUnitsExclusions.Add(PositionUnitType.PixelsFromBottom); xUnitsExclusions.Add(PositionUnitType.PixelsFromCenterY); xUnitsExclusions.Add(PositionUnitType.PixelsFromCenterYInverted); List<object> yUnitsExclusions = new List<object>(); yUnitsExclusions.Add(PositionUnitType.PixelsFromLeft); yUnitsExclusions.Add(PositionUnitType.PixelsFromCenterX); yUnitsExclusions.Add(PositionUnitType.PercentageWidth); yUnitsExclusions.Add(PositionUnitType.PixelsFromRight); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 0.0f, Name = "X", Category = "Position" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = typeof(PositionUnitType).Name, Value = PositionUnitType.PixelsFromLeft, Name = "X Units", Category = "Position", ExcludedValuesForEnum = xUnitsExclusions }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 0.0f, Name = "Y", Category = "Position" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = typeof(PositionUnitType).Name, Value = PositionUnitType.PixelsFromTop, Name = "Y Units", Category = "Position", ExcludedValuesForEnum = yUnitsExclusions }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "HorizontalAlignment", Value = HorizontalAlignment.Left, Name = "X Origin", Category = "Position" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "VerticalAlignment", Value = VerticalAlignment.Top, Name = "Y Origin", Category = "Position" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "string", Value = null, Name = "Guide", Category = "Position" }); #if GUM AddParentVariables(stateSave); #endif }
private static void AddParentVariables(StateSave variables) { VariableSave variableSave = new VariableSave(); variableSave.SetsValue = true; variableSave.Type = "string"; variableSave.Name = "Parent"; variableSave.CanOnlyBeSetInDefaultState = true; variableSave.CustomTypeConverter = new AvailableInstancesConverter() { IncludeScreenBounds = true }; variables.Variables.Add(variableSave); }
public void Deserialize(ScriptData instance, StateSave save) { instance.State = save.State; instance.Running = save.Running; instance.EventDelayTicks = (long) save.MinEventDelay; instance.AssemblyName = save.AssemblyName; instance.Disabled = save.Disabled; instance.UserInventoryItemID = save.UserInventoryID; if (save.Plugins != "") instance.PluginData = (OSDMap) OSDParser.DeserializeJson(save.Plugins); m_module.CreateFromData(instance.Part.UUID, instance.ItemID, instance.Part.UUID, instance.PluginData); instance.Source = save.Source; instance.InventoryItem.PermsGranter = save.PermsGranter; instance.InventoryItem.PermsMask = save.PermsMask; instance.TargetOmegaWasSet = save.TargetOmegaWasSet; if (save.Variables != null && instance.Script != null) instance.Script.SetStoreVars(XMLUtils.ParseXmlResponse(save.Variables)); }
private static void AddDimensionsVariables(StateSave stateSave, float defaultWidth, float defaultHeight, DimensionVariableAction dimensionVariableAction) { stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = defaultWidth, Name = "Width", Category = "Dimensions" }); var defaultValue = DimensionUnitType.Absolute; if(dimensionVariableAction == DimensionVariableAction.DefaultToPercentageOfFile) { defaultValue = DimensionUnitType.PercentageOfSourceFile; } VariableSave variableSave = new VariableSave { SetsValue = true, Type = typeof(DimensionUnitType).Name, Value = defaultValue, Name = "Width Units", Category = "Dimensions" }; if (dimensionVariableAction == DimensionVariableAction.ExcludeFileOptions) { variableSave.ExcludedValuesForEnum.Add(DimensionUnitType.PercentageOfSourceFile); } stateSave.Variables.Add(variableSave); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = defaultHeight, Name = "Height", Category = "Dimensions" }); variableSave = new VariableSave { SetsValue = true, Type = typeof(DimensionUnitType).Name, Value = defaultValue, Name = "Height Units", Category = "Dimensions" }; if (dimensionVariableAction == DimensionVariableAction.ExcludeFileOptions) { variableSave.ExcludedValuesForEnum.Add(DimensionUnitType.PercentageOfSourceFile); } stateSave.Variables.Add(variableSave); }
public void Select(StateSave stateSave) { TreeNode treeNode = GetTreeNodeForTag(stateSave); Select(treeNode); }
UndoObject(StateSave objectToSave, List<InstanceSave> instances, object parent) { mStateSave = objectToSave; Instances = instances; Parent = parent; }
internal void ModifyDefaultStandardState(string type, StateSave stateSave) { CallMethodOnPlugin( delegate(PluginBase plugin) { plugin.CallAddAndRemoveVariablesForType(type, stateSave); }, "ModifyDefaultStandardState" ); }
public void Initialize() { mDefaults = new Dictionary<string, StateSave>(); // Eventually this would get read from somewhere like an XML file // or a CSV file, but for // now we'll just use hard values. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Text // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// StateSave stateSave = new StateSave(); stateSave.Name = "Default"; AddPositioningVariables(stateSave); AddDimensionsVariables(stateSave, 100, 50, DimensionVariableAction.ExcludeFileOptions); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = true, Name = "Visible" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "string", Value = "Hello", Name = "Text", Category = "Text" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "VerticalAlignment", Value = VerticalAlignment.Top, Name = "VerticalAlignment", Category = "Text" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "HorizontalAlignment", Value = HorizontalAlignment.Left, Name = "HorizontalAlignment", Category = "Text" }); // font: stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "UseCustomFont", Category = "Font" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "string", Value = "Arial", Name = "Font", IsFont = true, Category = "Font" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 18, Name = "FontSize", Category = "Font" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 0, Name = "OutlineThickness", Category = "Font" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "string", Value = "", Name = "CustomFontFile", Category = "Font", IsFile = true }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 1.0f, Name = "Font Scale", Category = "Font" }); stateSave.Variables.Add(new VariableSave { Type = "float", Value = 0.0f, Category = "Flip and Rotation", Name = "Rotation" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "HasEvents", Category = "Behavior", CanOnlyBeSetInDefaultState = true }); AddStateVariable(stateSave); AddColorVariables(stateSave, includeAlpha:true); #if GUM PluginManager.Self.ModifyDefaultStandardState("Text", stateSave); #endif ApplySortValuesFromOrderInState(stateSave); mDefaults.Add("Text", stateSave); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Sprite // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// stateSave = new StateSave(); stateSave.Name = "Default"; AddPositioningVariables(stateSave); AddDimensionsVariables(stateSave, 100, 100, DimensionVariableAction.DefaultToPercentageOfFile); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "string", Value = "", Name = "SourceFile", IsFile = true }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = true, Name = "Visible" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Category = "Animation", Name = "Animate" }); stateSave.Variables.Add(new VariableSave { Type = "float", Value = 0.0f, Category = "Flip and Rotation", Name = "Rotation" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Category = "Flip", Name = "FlipHorizontal" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Category = "Flip", Name = "FlipVertical" }); //stateSave.Variables.Add(new VariableSave { Type = "bool", Value = false, Name = "Custom Texture Coordinates", Category="Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "TextureAddress", Value = Gum.Managers.TextureAddress.EntireTexture, Name = "Texture Address", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 0, Name = "Texture Top", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 0, Name = "Texture Left", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 0, Name = "Texture Width", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 0, Name = "Texture Height", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 0.0f, Name = "Texture Width Scale", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 0.0f, Name = "Texture Height Scale", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "Wrap", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "HasEvents", Category = "Behavior", CanOnlyBeSetInDefaultState = true }); AddColorVariables(stateSave); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "Blend", Value = Blend.Normal, Name = "Blend", Category = "Rendering" }); AddStateVariable(stateSave); List<string> list = new List<string>(); stateSave.VariableLists.Add(new VariableListSave<string> { Type = "string", Value = list, Category = "Animation", Name = "AnimationFrames"}); #if GUM PluginManager.Self.ModifyDefaultStandardState("Sprite", stateSave); #endif ApplySortValuesFromOrderInState(stateSave); mDefaults.Add("Sprite", stateSave); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Container // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// stateSave = new StateSave(); stateSave.Name = "Default"; AddPositioningVariables(stateSave); AddDimensionsVariables(stateSave, 150, 150, DimensionVariableAction.ExcludeFileOptions); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = true, Name = "Visible" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "ChildrenLayout", Value = ChildrenLayout.Regular, Name = "Children Layout" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "Wraps Children" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "Clips Children" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "HasEvents", Category = "Behavior", CanOnlyBeSetInDefaultState = true }); #if GUM PluginManager.Self.ModifyDefaultStandardState("Container", stateSave); #endif ApplySortValuesFromOrderInState(stateSave); mDefaults.Add("Container", stateSave); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // ColoredRectangle // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// stateSave = new StateSave(); stateSave.Name = "Default"; AddPositioningVariables(stateSave); AddDimensionsVariables(stateSave, 50, 50, DimensionVariableAction.ExcludeFileOptions); stateSave.Variables.Add(new VariableSave { Type = "float", Value = 0.0f, Category = "Flip and Rotation", Name = "Rotation" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = true, Name = "Visible" }); AddColorVariables(stateSave, true); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "Blend", Value = Blend.Normal, Name = "Blend", Category = "Rendering" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "HasEvents", Category = "Behavior", CanOnlyBeSetInDefaultState = true }); AddStateVariable(stateSave); #if GUM PluginManager.Self.ModifyDefaultStandardState("ColoredRectangle", stateSave); #endif ApplySortValuesFromOrderInState(stateSave); mDefaults.Add("ColoredRectangle", stateSave); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Circle // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// stateSave = new StateSave(); stateSave.Name = "Default"; AddPositioningVariables(stateSave); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 16.0f, Name = "Radius" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 16.0f, Name = "Width", IsHiddenInPropertyGrid = true }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 16.0f, Name = "Height", IsHiddenInPropertyGrid = true }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = true, Name = "Visible" }); //AddColorVariables(stateSave, true); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "HasEvents", Category = "Behavior", CanOnlyBeSetInDefaultState = true }); AddStateVariable(stateSave); #if GUM PluginManager.Self.ModifyDefaultStandardState("Circle", stateSave); #endif ApplySortValuesFromOrderInState(stateSave); mDefaults.Add("Circle", stateSave); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Rectangle // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// stateSave = new StateSave(); stateSave.Name = "Default"; AddPositioningVariables(stateSave); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 16.0f, Name = "Width" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "float", Value = 16.0f, Name = "Height" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = true, Name = "Visible" }); //AddColorVariables(stateSave, true); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "HasEvents", Category = "Behavior", CanOnlyBeSetInDefaultState = true }); AddStateVariable(stateSave); #if GUM PluginManager.Self.ModifyDefaultStandardState("Rectangle", stateSave); #endif ApplySortValuesFromOrderInState(stateSave); mDefaults.Add("Rectangle", stateSave); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // NineSlice // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// stateSave = new StateSave(); stateSave.Name = "Default"; AddPositioningVariables(stateSave); AddDimensionsVariables(stateSave, 64, 64, DimensionVariableAction.ExcludeFileOptions); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "string", Value = "", Name = "SourceFile", IsFile = true }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = true, Name = "Visible" }); AddColorVariables(stateSave); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "Blend", Value = Blend.Normal, Name = "Blend", Category = "Rendering" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "TextureAddress", Value = Gum.Managers.TextureAddress.EntireTexture, Name = "Texture Address", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 0, Name = "Texture Top", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 0, Name = "Texture Left", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 0, Name = "Texture Width", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 0, Name = "Texture Height", Category = "Source" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "bool", Value = false, Name = "HasEvents", Category = "Behavior", CanOnlyBeSetInDefaultState = true }); AddStateVariable(stateSave); #if GUM PluginManager.Self.ModifyDefaultStandardState("NineSlice", stateSave); #endif ApplySortValuesFromOrderInState(stateSave); mDefaults.Add("NineSlice", stateSave); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Component // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// stateSave = new StateSave(); stateSave.Name = "Default"; #if GUM PluginManager.Self.ModifyDefaultStandardState("Component", stateSave); #endif #if GUM // Victor Chelaru // August 21, 2014 // Not sure why we have // this here. Doing so would // create an endless loop... //stateSave.Variables.Add(new VariableSave { Type = "string", Value = "Default", Name = "State", CustomTypeConverter = new AvailableStatesConverter(null)}); // The type used to be "string" but we want to differentiate it from actual strings so we use "State" stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "State", Value = null, Name = "State", CustomTypeConverter = new AvailableStatesConverter(null) }); #endif ApplySortValuesFromOrderInState(stateSave); mDefaults.Add("Component", stateSave); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Screen // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// stateSave = new StateSave(); stateSave.Name = "Default"; #if GUM PluginManager.Self.ModifyDefaultStandardState("Screen", stateSave); #endif ApplySortValuesFromOrderInState(stateSave); mDefaults.Add("Screen", stateSave); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // We shouldn't do this because states above may explicitly not want to set values - like the variable for state //foreach (var defaultState in mDefaults.Values) //{ // foreach (var variable in defaultState.Variables) // { // variable.SetsValue = true; // } //} //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Events // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// mStandardEvents.Add("Click"); mStandardEvents.Add("RollOn"); mStandardEvents.Add("RollOver"); mStandardEvents.Add("RollOff"); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// }
public void AddState(ElementSave elementToAddTo, StateSaveCategory category, StateSave stateSave) { stateSave.ParentContainer = elementToAddTo; if (category == null) { elementToAddTo.States.Add(stateSave); } else { category.States.Add(stateSave); } }
public StateSave AddState(ElementSave elementToAddTo, StateSaveCategory category, string name) { if (elementToAddTo == 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); return stateSave; }
public void PasteInstanceSaves(List<InstanceSave> copiedInstances, StateSave copiedState, ElementSave targetElement) { List<InstanceSave> newInstances = new List<InstanceSave>(); foreach (var instanceAsObject in copiedInstances) { InstanceSave sourceInstance = instanceAsObject as InstanceSave; ElementSave sourceElement = sourceInstance.ParentContainer; InstanceSave targetInstance = sourceInstance.Clone(); newInstances.Add(targetInstance); if (targetElement != null) { PastedCopiedInstance(sourceInstance, sourceElement, targetElement, targetInstance, copiedState); } } if (newInstances.Count > 1) { SelectedState.Self.SelectedInstances = newInstances; } }
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); }
private void StoreCopiedInstances() { if (SelectedState.Self.SelectedInstance != null) { var element = SelectedState.Self.SelectedElement; // When copying we want to grab all instances in the order that they are in their container. // That way when they're pasted they are pasted in the right order foreach (var instance in SelectedState.Self.SelectedInstances.OrderBy(item=>element.Instances.IndexOf(item))) { mCopiedInstances.Add(instance.Clone()); } mCopiedState = SelectedState.Self.SelectedStateSave.Clone(); // Clear out any variables that don't pertain to the selected instance: for (int i = mCopiedState.Variables.Count - 1; i > -1; i--) { if (mCopiedInstances.Any(item=>item.Name == mCopiedState.Variables[i].SourceObject) == false) { mCopiedState.Variables.RemoveAt(i); } } // And also any VariableLists: for (int i = mCopiedState.VariableLists.Count - 1; i > -1; i--) { if (mCopiedInstances.Any(item=>item.Name == mCopiedState.VariableLists[i].SourceObject) == false) { mCopiedState.VariableLists.RemoveAt(i); } } } }
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 static void AddStateVariable(StateSave stateSave) { stateSave.Variables.Add(new VariableSave { // Don't want it to set the value... SetsValue = false, Type = "State", Value = "Default", Name = "State" #if GUM , CustomTypeConverter = new AvailableStatesConverter(null) #endif }); }
private void RefreshDataGrid(ElementSave element, StateSave state, InstanceSave instance, bool force = false) { bool hasChangedObjectShowing = element != mLastElement || instance != mLastInstance || state != mLastState || force; if (hasChangedObjectShowing) { List<MemberCategory> categories = GetCategories(element, state, instance); Application.DoEvents(); SimultaneousCalls ++; lock (lockObject) { if(SimultaneousCalls > 1) { SimultaneousCalls--; return; } records.Add("in"); mVariablesDataGrid.Instance = SelectedState.Self.SelectedStateSave; mVariablesDataGrid.Visibility = System.Windows.Visibility.Hidden; mVariablesDataGrid.Categories.Clear(); // There's a bug here where drag+dropping a new instance will create // duplicate UI members. I am going to deal with it now because it is foreach (var category in categories) { // We used to do this: // Application.DoEvents(); // That made things go faster, // but it made the "lock" not work, which could make duplicate UI show up. mVariablesDataGrid.Categories.Add(category); if(SimultaneousCalls > 1) { SimultaneousCalls--; // EARLY OUT!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! return; } } } SimultaneousCalls--; Application.DoEvents(); mVariablesDataGrid.Visibility = System.Windows.Visibility.Visible; } else { // let's see if any variables have been added/removed var categories = GetCategories(element, state, instance); foreach (var newCategory in categories) { // let's see if any variables have changed var oldCategory = mVariablesDataGrid.Categories.FirstOrDefault(item => item.Name == newCategory.Name); if ( oldCategory != null && DoCategoriesDiffer(oldCategory.Members, newCategory.Members)) { int index = mVariablesDataGrid.Categories.IndexOf(oldCategory); mVariablesDataGrid.Categories.RemoveAt(index); mVariablesDataGrid.Categories.Insert(index, newCategory); } } } mVariablesDataGrid.Refresh(); }
private void ApplySortValuesFromOrderInState(StateSave stateSave) { for (int i = 0; i < stateSave.Variables.Count; i++) { stateSave.Variables[i].DesiredOrder = i; } }
public void CallAddAndRemoveVariablesForType(string type, StateSave standardDefaultStateSave) { if (AddAndRemoveVariablesForType != null) { AddAndRemoveVariablesForType(type, standardDefaultStateSave); } }
private static void AddColorVariables(StateSave stateSave, bool includeAlpha = true) { if (includeAlpha) { stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 255, Name = "Alpha", Category = "Rendering" }); } stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 255, Name = "Red", Category = "Rendering" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 255, Name = "Green", Category = "Rendering" }); stateSave.Variables.Add(new VariableSave { SetsValue = true, Type = "int", Value = 255, Name = "Blue", Category = "Rendering" }); }
private void StoreCopiedState() { if (SelectedState.Self.SelectedStateSave != null) { mCopiedState = SelectedState.Self.SelectedStateSave.Clone(); } }
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; }
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 }
public void SaveStateTo(ScriptData script, bool forced, bool saveBackup) { if (!forced) { if (script.Script == null) return; //If it didn't compile correctly, this happens if (!script.Script.NeedsStateSaved) return; //If it doesn't need a state save, don't save one } if (script.Script != null) script.Script.NeedsStateSaved = false; StateSave stateSave = new StateSave { State = script.State, ItemID = script.ItemID, Running = script.Running, MinEventDelay = script.EventDelayTicks, Disabled = script.Disabled, UserInventoryID = script.UserInventoryItemID, AssemblyName = script.AssemblyName, Compiled = script.Compiled, Source = script.Source == null ? "" : script.Source }; //Allow for the full path to be put down, not just the assembly name itself if (script.InventoryItem != null) { stateSave.PermsGranter = script.InventoryItem.PermsGranter; stateSave.PermsMask = script.InventoryItem.PermsMask; } else { stateSave.PermsGranter = UUID.Zero; stateSave.PermsMask = 0; } stateSave.TargetOmegaWasSet = script.TargetOmegaWasSet; //Vars Dictionary<string, object> vars = new Dictionary<string, object>(); if (script.Script != null) vars = script.Script.GetStoreVars(); stateSave.Variables = XMLUtils.BuildXmlResponse(vars); //Plugins stateSave.Plugins = OSDParser.SerializeJsonString(m_module.GetSerializationData(script.ItemID, script.Part.UUID)); lock (StateSaveLock) script.Part.StateSaves[script.ItemID] = stateSave; if (saveBackup) script.Part.ParentEntity.HasGroupChanged = true; }