Пример #1
0
        private void GenerateEnums(ICodeBlock codeBlock, BehaviorSave behavior)
        {
            foreach(var category in behavior.Categories)
            {
                codeBlock = codeBlock.Enum("public", category.Name);
            }

        }
Пример #2
0
        private void GenerateInterface(ICodeBlock codeBlock, BehaviorSave behavior)
        {

            foreach (var category in behavior.Categories)
            {
                string propertyName = behavior.Name + category.Name;

                codeBlock.Line($"{propertyName} Current{propertyName}State {{set;}}");
            }

        }
Пример #3
0
        internal string GenerateInterfaceCodeFor(BehaviorSave behavior)
        {
            CodeBlockBase fileLevel = new CodeBlockBase(null);
            ICodeBlock namespaceLevel = fileLevel.Namespace(GueDerivingClassCodeGenerator.GueRuntimeNamespace);

            StateCodeGenerator.Self.GenerateStateEnums(behavior, namespaceLevel, enumNamePrefix:behavior.Name);


            ICodeBlock interfaceLevel = namespaceLevel.Interface("public", $"I{behavior.Name}", "");


            GenerateInterface(interfaceLevel, behavior);

            return fileLevel.ToString();
        }
Пример #4
0
 public void RemoveBehaviorVariable(BehaviorSave container, VariableSave variable)
 {
     container.RequiredVariables.Variables.Remove(variable);
     GumCommands.Self.FileCommands.TryAutoSaveBehavior(container);
     PropertyGridManager.Self.RefreshUI();
 }
Пример #5
0
        public static BehaviorSave CreateListBoxItemBehavior()
        {
            BehaviorSave toReturn = CreateBehaviorSaveFrom(FormsControlInfo.ListBoxItem);

            return(toReturn);
        }
Пример #6
0
        private void ForceSaveBehavior(BehaviorSave behavior)
        {
            if (behavior.IsSourceFileMissing)
            {
                MessageBox.Show("Cannot save " + behavior + " because its source file is missing");
            }
            else
            {
                bool succeeded = true;

                UndoManager.Self.RecordUndo();

                bool doesProjectNeedToSave = false;
                bool shouldSave            = ProjectManager.Self.AskUserForProjectNameIfNecessary(out doesProjectNeedToSave);

                if (doesProjectNeedToSave)
                {
                    ProjectManager.Self.SaveProject();
                }

                if (shouldSave)
                {
                    //PluginManager.Self.BeforeBehaviorSave(behavior);

                    string fileName = behavior.GetFullPathXmlFile();
                    FileWatchLogic.Self.IgnoreNextChangeOn(fileName);
                    // if it's readonly, let's warn the user
                    bool isReadOnly = ProjectManager.IsFileReadOnly(fileName);

                    if (isReadOnly)
                    {
                        ProjectManager.ShowReadOnlyDialog(fileName);
                    }
                    else
                    {
                        const int maxNumberOfTries   = 5;
                        const int msBetweenSaves     = 100;
                        int       numberOfTimesTried = 0;

                        succeeded = false;
                        Exception exception = null;

                        while (numberOfTimesTried < maxNumberOfTries)
                        {
                            try
                            {
                                FileManager.XmlSerialize(behavior.GetType(), behavior, fileName);

                                succeeded = true;
                                break;
                            }
                            catch (Exception e)
                            {
                                exception = e;
                                System.Threading.Thread.Sleep(msBetweenSaves);
                                numberOfTimesTried++;
                            }
                        }


                        if (succeeded == false)
                        {
                            MessageBox.Show("Unknown error trying to save the file\n\n" + fileName + "\n\n" + exception.ToString());
                            succeeded = false;
                        }
                    }
                    if (succeeded)
                    {
                        OutputManager.Self.AddOutput("Saved " + behavior + " to " + fileName);
                        //PluginManager.Self.AfterBehaviorSave(behavior);
                    }
                }

                //PluginManager.Self.Export(elementSave);
            }
        }
Пример #7
0
 public static string GetFullPathXmlFile(this BehaviorSave behaviorSave)
 {
     return(behaviorSave.GetFullPathXmlFile(behaviorSave.Name));
 }
Пример #8
0
        private void AddAndRemoveScreensComponentsAndStandards(TreeNode folderTreeNode)
        {
            if (ProjectManager.Self.GumProjectSave == null)
            {
                return;
            }

            // Save off old selected stuff
            InstanceSave selectedInstance = SelectedState.Self.SelectedInstance;
            ElementSave  selectedElement  = SelectedState.Self.SelectedElement;
            BehaviorSave selectedBehavior = SelectedState.Self.SelectedBehavior;


            if (!string.IsNullOrEmpty(ProjectManager.Self.GumProjectSave.FullFileName))
            {
                string currentDirectory = FileManager.GetDirectory(ProjectManager.Self.GumProjectSave.FullFileName);

                if (folderTreeNode != null)
                {
                    currentDirectory = folderTreeNode.GetFullFilePath();
                }
            }



            #region Add nodes that haven't been added yet

            foreach (ScreenSave screenSave in ProjectManager.Self.GumProjectSave.Screens)
            {
                if (GetTreeNodeFor(screenSave) == null)
                {
                    string   fullPath   = FileLocations.Self.ScreensFolder + FileManager.GetDirectory(screenSave.Name);
                    TreeNode parentNode = GetTreeNodeFor(fullPath);

                    AddTreeNodeForElement(screenSave, parentNode, ScreenImageIndex);
                }
            }

            foreach (ComponentSave componentSave in ProjectManager.Self.GumProjectSave.Components)
            {
                if (GetTreeNodeFor(componentSave) == null)
                {
                    string   fullPath   = FileLocations.Self.ComponentsFolder + FileManager.GetDirectory(componentSave.Name);
                    TreeNode parentNode = GetTreeNodeFor(fullPath);

                    if (parentNode == null)
                    {
                        throw new Exception($"Error trying to get parent node for component {fullPath}");
                    }

                    AddTreeNodeForElement(componentSave, parentNode, ComponentImageIndex);
                }
            }

            foreach (StandardElementSave standardSave in ProjectManager.Self.GumProjectSave.StandardElements)
            {
                if (standardSave.Name != "Component")
                {
                    if (GetTreeNodeFor(standardSave) == null)
                    {
                        AddTreeNodeForElement(standardSave, mStandardElementsTreeNode, StandardElementImageIndex);
                    }
                }
            }

            foreach (BehaviorSave behaviorSave in ProjectManager.Self.GumProjectSave.Behaviors)
            {
                if (GetTreeNodeFor(behaviorSave) == null)
                {
                    string   fullPath   = FileLocations.Self.BehaviorsFolder + FileManager.GetDirectory(behaviorSave.Name);
                    TreeNode parentNode = GetTreeNodeFor(fullPath);

                    AddTreeNodeForBehavior(behaviorSave, parentNode, BehaviorImageIndex);
                }
            }

            #endregion

            #region Remove nodes that are no longer needed

            for (int i = mScreensTreeNode.Nodes.Count - 1; i > -1; i--)
            {
                ScreenSave screen = mScreensTreeNode.Nodes[i].Tag as ScreenSave;

                // If the screen is null, that means that it's a folder TreeNode, so we don't want to remove it
                if (screen != null)
                {
                    if (!ProjectManager.Self.GumProjectSave.Screens.Contains(screen))
                    {
                        mScreensTreeNode.Nodes.RemoveAt(i);
                    }
                }
            }

            for (int i = mComponentsTreeNode.Nodes.Count - 1; i > -1; i--)
            {
                ComponentSave component = mComponentsTreeNode.Nodes[i].Tag as ComponentSave;

                // If the component is null, that means that it's a folder TreeNode, so we don't want to remove it
                if (component != null)
                {
                    if (!ProjectManager.Self.GumProjectSave.Components.Contains(component))
                    {
                        mComponentsTreeNode.Nodes.RemoveAt(i);
                    }
                }
            }

            for (int i = mStandardElementsTreeNode.Nodes.Count - 1; i > -1; i--)
            {
                // Do we want to support folders here?
                StandardElementSave standardElement = mStandardElementsTreeNode.Nodes[i].Tag as StandardElementSave;

                if (!ProjectManager.Self.GumProjectSave.StandardElements.Contains(standardElement))
                {
                    mStandardElementsTreeNode.Nodes.RemoveAt(i);
                }
            }

            for (int i = mBehaviorsTreeNode.Nodes.Count - 1; i > -1; i--)
            {
                BehaviorSave behavior = mBehaviorsTreeNode.Nodes[i].Tag as BehaviorSave;

                if (behavior != null)
                {
                    if (!ProjectManager.Self.GumProjectSave.Behaviors.Contains(behavior))
                    {
                        mBehaviorsTreeNode.Nodes.RemoveAt(i);
                    }
                }
            }

            #endregion

            #region Update the nodes

            foreach (TreeNode treeNode in mScreensTreeNode.Nodes)
            {
                RefreshUi(treeNode);
            }

            foreach (TreeNode treeNode in mComponentsTreeNode.Nodes)
            {
                RefreshUi(treeNode);
            }

            foreach (TreeNode treeNode in mStandardElementsTreeNode.Nodes)
            {
                RefreshUi(treeNode);
            }

            foreach (TreeNode treeNode in mBehaviorsTreeNode.Nodes)
            {
                RefreshUi(treeNode);
            }

            #endregion

            #region Sort everything

            mScreensTreeNode.Nodes.SortByName(recursive: true);

            mComponentsTreeNode.Nodes.SortByName(recursive: true);

            mStandardElementsTreeNode.Nodes.SortByName(recursive: true);

            mBehaviorsTreeNode.Nodes.SortByName(recursive: true);

            #endregion

            #region Re-select whatever was selected before

            if (selectedInstance != null)
            {
                SelectedState.Self.SelectedInstance = selectedInstance;
            }
            if (selectedBehavior != null)
            {
                SelectedState.Self.SelectedBehavior = selectedBehavior;
            }
            #endregion
        }
Пример #9
0
 public TreeNode GetTreeNodeFor(BehaviorSave behavior)
 {
     return(GetTreeNodeForTag(behavior, RootBehaviorsTreeNode));
 }
Пример #10
0
        private void PopulateElementSavesFromReferences(string projectRootDirectory, GumLoadResult result)
        {
            string errors = "";

            Screens.Clear();
            Components.Clear();
            StandardElements.Clear();
            Behaviors.Clear();

            foreach (ElementReference reference in ScreenReferences)
            {
                ScreenSave toAdd = null;
                try
                {
                    toAdd = reference.ToElementSave <ScreenSave>(projectRootDirectory, ScreenExtension, result);
                }
                catch (Exception e)
                {
                    errors += "\nError loading " + reference.Name + ":\n" + e.Message;
                }
                if (toAdd != null)
                {
                    Screens.Add(toAdd);
                }
            }

            foreach (ElementReference reference in ComponentReferences)
            {
                ComponentSave toAdd = null;

                try
                {
                    toAdd = reference.ToElementSave <ComponentSave>(projectRootDirectory, ComponentExtension, result);
                }
                catch (Exception e)
                {
                    errors += "\nError loading " + reference.Name + ":\n" + e.Message;
                }
                if (toAdd != null)
                {
                    Components.Add(toAdd);
                }
            }

            foreach (ElementReference reference in StandardElementReferences)
            {
                StandardElementSave toAdd = null;
                try
                {
                    toAdd = reference.ToElementSave <StandardElementSave>(projectRootDirectory, StandardExtension, result);
                }
                catch (Exception e)
                {
                    errors += "\nError loading " + reference.Name + ":\n" + e.Message;
                }
                if (toAdd != null)
                {
                    StandardElements.Add(toAdd);
                }
            }

            foreach (var reference in BehaviorReferences)
            {
                BehaviorSave toAdd = null;

                try
                {
                    toAdd = reference.ToBehaviorSave(projectRootDirectory);
                }
                catch (Exception e)
                {
                    errors += "\nError loading " + reference.Name + ":\n" + e.Message;
                }
                if (toAdd != null)
                {
                    Behaviors.Add(toAdd);
                }
            }

            result.ErrorMessage += errors;
        }
Пример #11
0
        /// <summary>
        /// Refreshes the property grid for the argument element, state, and instance. This will only refresh the grid
        /// if the element, state, or instance values have changed since the last time this function was called, or if
        /// force is true.
        /// </summary>
        /// <param name="element">The element to display. The properties on this element may not be displayed if the instance is not null.</param>
        /// <param name="state">The state to display.</param>
        /// <param name="instance">The instance to display. May be null.</param>
        /// <param name="force">Whether to refresh even if the element, state, and instance have not changed.</param>
        private void RefreshDataGrid(ElementSave element, StateSave state, StateSaveCategory category, InstanceSave instance,
                                     BehaviorSave behaviorSave, bool force = false)
        {
            bool hasChangedObjectShowing = element != mLastElement ||
                                           instance != mLastInstance ||
                                           state != mLastState ||
                                           category != mLastCategory ||
                                           force;


            if (hasChangedObjectShowing)
            {
                List <MemberCategory> categories = GetMemberCategories(element, state, category, 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 memberCategory 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(memberCategory);
                        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 = GetMemberCategories(element, state, category, 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);
                    }
                }
            }

            RefreshErrors(element);

            RefreshBehaviorUi(behaviorSave);

            mVariablesDataGrid.Refresh();
        }