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