Add scaffolding for general purpose actions

OpenChart.Tests/src/Actions/TestCloseProjectAction.cs

@@ -1,6 +1,6 @@
 using NUnit.Framework;
 using OpenChart.Projects;
-using OpenChart.UI.Actions;
+using OpenChart.UI.MenuActions;
 
 namespace OpenChart.Tests.Actions
 {

OpenChart.Tests/src/Actions/TestNewProjectAction.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using OpenChart.UI.Actions;
+using OpenChart.UI.MenuActions;
 
 namespace OpenChart.Tests.Actions
 {

OpenChart.Tests/src/Actions/TestQuitAction.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using OpenChart.UI.Actions;
+using OpenChart.UI.MenuActions;
 
 namespace OpenChart.Tests.Actions
 {

OpenChart.Tests/src/Actions/TestSaveAction.cs

@@ -1,6 +1,6 @@
 using NUnit.Framework;
 using OpenChart.Projects;
-using OpenChart.UI.Actions;
+using OpenChart.UI.MenuActions;
 
 namespace OpenChart.Tests.Actions
 {

OpenChart.Tests/src/Actions/TestSaveAsAction.cs

@@ -1,6 +1,6 @@
 using NUnit.Framework;
 using OpenChart.Projects;
-using OpenChart.UI.Actions;
+using OpenChart.UI.MenuActions;
 
 namespace OpenChart.Tests.Actions
 {

OpenChart.Tests/src/TestApplication.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using OpenChart.UI.Actions;
+using OpenChart.UI.MenuActions;
 
 namespace OpenChart.Tests
 {

OpenChart/src/Application.cs

@@ -1,5 +1,5 @@
 using ManagedBass;
-using OpenChart.UI.Actions;
+using OpenChart.UI.MenuActions;
 using OpenChart.UI.Windows;
 using Serilog;
 using System;
@@ -19,7 +19,7 @@ public class Application : Gtk.Application, IApplication
         /// <summary>
         /// A dictionary of action names --> actions.
         /// </summary>
-        public Dictionary<string, IAction> ActionDict { get; private set; }
+        public Dictionary<string, IMenuAction> ActionDict { get; private set; }
 
         ApplicationData applicationData;
         public ApplicationData GetData() => applicationData;
@@ -36,7 +36,7 @@ public class Application : Gtk.Application, IApplication
 
         public Application() : base(AppId, GLib.ApplicationFlags.None)
         {
-            ActionDict = new Dictionary<string, IAction>();
+            ActionDict = new Dictionary<string, IMenuAction>();
             LogFile = Path.Combine("logs", "OpenChart.log");
         }
 
@@ -55,12 +55,12 @@ public void Cleanup()
         public void InitActions()
         {
             // File actions
-            addAction(new NewProjectAction(this));
-            addAction(new NewChartAction(this));
-            addAction(new CloseProjectAction(this));
-            addAction(new SaveAction(this));
-            addAction(new SaveAsAction(this));
-            addAction(new QuitAction(this));
+            addMenuAction(new NewProjectAction(this));
+            addMenuAction(new NewChartAction(this));
+            addMenuAction(new CloseProjectAction(this));
+            addMenuAction(new SaveAction(this));
+            addMenuAction(new SaveAsAction(this));
+            addMenuAction(new QuitAction(this));
         }
 
         /// <summary>
@@ -195,7 +195,7 @@ protected override void OnStartup()
             }
         }
 
-        private void addAction(IAction action)
+        private void addMenuAction(IMenuAction action)
         {
             // FIXME: Can't add accelerators/hotkeys since the Gtk wrapper takes the wrong
             // type of argument, resulting in a segfault.

OpenChart/src/ApplicationData.cs

@@ -2,6 +2,7 @@
 using OpenChart.Formats.OpenChart.Version0_1;
 using OpenChart.NoteSkins;
 using OpenChart.Projects;
+using OpenChart.UI.Actions;
 using Serilog;
 using System;
 
@@ -27,6 +28,11 @@ public ProjectChangedEventArgs(Project oldProject, Project newProject)
     /// </summary>
     public class ApplicationData
     {
+        /// <summary>
+        /// A factory for producing IAction instances.
+        /// </summary>
+        public ActionFactory ActionFactory { get; private set; }
+
         /// <summary>
         /// The absolute path to the folder where the OpenChart executable is.
         /// </summary>
@@ -80,6 +86,7 @@ public Project CurrentProject
         public ApplicationData(string appFolder)
         {
             AppFolder = appFolder;
+            ActionFactory = new ActionFactory(this);
             Formats = new FormatManager();
             NoteSkins = new NoteSkinManager();
         }

OpenChart/src/ApplicationEventBus.cs

@@ -1,3 +1,4 @@
+using OpenChart.UI.MenuActions;
 using OpenChart.Charting;
 using OpenChart.Projects;
 using System;

OpenChart/src/UI/Actions/ActionFactory.cs

@@ -0,0 +1,21 @@
+namespace OpenChart.UI.Actions
+{
+    /// <summary>
+    /// A factory class for creating IAction instances.
+    /// </summary>
+    public class ActionFactory
+    {
+        /// <summary>
+        /// The application data.
+        /// </summary>
+        public ApplicationData ApplicationData { get; private set; }
+
+        /// <summary>
+        /// Creates a new ActionFactory instance.
+        /// </summary>
+        public ActionFactory(ApplicationData appData)
+        {
+            ApplicationData = appData;
+        }
+    }
+}

OpenChart/src/UI/Actions/IAction.cs

@@ -1,35 +1,15 @@
 namespace OpenChart.UI.Actions
 {
     /// <summary>
-    /// An interface for an action. These actions are fairly analagous to the Command pattern,
-    /// the key difference being that once an action is created it lives for the lifecycle
-    /// of the application.
-    ///
-    /// Action instances are stored in <see cref="OpenChart.Application.ActionDict" /> and can
-    /// be retrieved by their name.
-    ///
-    /// For dynamic actions that need to respond to the state of the application (such as only
-    /// allowing the "Close Project" action to fire when a project is actually loaded), actions
-    /// should add event listener(s) to <see cref="OpenChart.Application.EventBus" /> and respond
-    /// to those events within the action class itself. Keeping all of the action-related code
-    /// inside the action classes makes it easy to find later on.
+    /// An interface for a general purpose action. These actions differ from menu actions in that
+    /// the menu actions are meant to be the UI part whereas classes that implement IAction are
+    /// the logical part. Menu actions most likely will end up calling an IAction instance.
     /// </summary>
     public interface IAction
     {
         /// <summary>
-        /// The GLib/Gtk action object.
+        /// Executes the action.
         /// </summary>
-        GLib.IAction Action { get; }
-
-        /// <summary>
-        /// The hotkey for the action.
-        /// </summary>
-        string GetHotkey();
-
-        /// <summary>
-        /// The name of the action. This is the name of the action referred to in
-        /// the code, not its display name. Display names are set in <see cref="OpenChart.UI.Actions.MenuModel" />
-        /// </summary>
-        string GetName();
+        void Run();
     }
 }

OpenChart/src/UI/Actions/IUndoable.cs

@@ -0,0 +1,20 @@
+namespace OpenChart.UI.Actions
+{
+    /// <summary>
+    /// An interface for an undoable action. Undoable actions appear in the Edit menu after they
+    /// are executed.
+    /// </summary>
+    public interface IUndoable
+    {
+        /// <summary>
+        /// Gets the name of the action as a string. This is the text that appears in the UI under
+        /// the Edit menu. It doesn't need to be constant.
+        /// </summary>
+        string GetName();
+
+        /// <summary>
+        /// Reverts the action.
+        /// </summary>
+        void Undo();
+    }
+}

OpenChart/src/UI/Actions/File/CloseProjectAction.cs → OpenChart/src/UI/MenuActions/File/CloseProjectAction.cs

@@ -1,12 +1,12 @@
 using Serilog;
 
-namespace OpenChart.UI.Actions
+namespace OpenChart.UI.MenuActions
 {
     /// <summary>
     /// An action that triggers the current active project to close. This action
     /// is only enabled when an active project is open.
     /// </summary>
-    public class CloseProjectAction : Actions.IAction
+    public class CloseProjectAction : IMenuAction
     {
         IApplication app;
 

OpenChart/src/UI/Actions/File/NewChartAction.cs → OpenChart/src/UI/MenuActions/File/NewChartAction.cs

@@ -2,12 +2,12 @@
 using OpenChart.Charting.Properties;
 using Serilog;
 
-namespace OpenChart.UI.Actions
+namespace OpenChart.UI.MenuActions
 {
     /// <summary>
     /// An action that triggers the application to create a new chart.
     /// </summary>
-    public class NewChartAction : Actions.IAction
+    public class NewChartAction : IMenuAction
     {
         IApplication app;
 

OpenChart/src/UI/Actions/File/NewProjectAction.cs → OpenChart/src/UI/MenuActions/File/NewProjectAction.cs

@@ -2,12 +2,12 @@
 using OpenChart.Projects;
 using Serilog;
 
-namespace OpenChart.UI.Actions
+namespace OpenChart.UI.MenuActions
 {
     /// <summary>
     /// An action that triggers the application to create a new project.
     /// </summary>
-    public class NewProjectAction : Actions.IAction
+    public class NewProjectAction : IMenuAction
     {
         IApplication app;
 

OpenChart/src/UI/Actions/File/QuitAction.cs → OpenChart/src/UI/MenuActions/File/QuitAction.cs

@@ -1,11 +1,11 @@
 using Serilog;
 
-namespace OpenChart.UI.Actions
+namespace OpenChart.UI.MenuActions
 {
     /// <summary>
     /// An action that triggers the application to quit.
     /// </summary>
-    public class QuitAction : Actions.IAction
+    public class QuitAction : IMenuAction
     {
         IApplication app;
 

OpenChart/src/UI/Actions/File/SaveAction.cs → OpenChart/src/UI/MenuActions/File/SaveAction.cs

@@ -1,11 +1,11 @@
 using Serilog;
 
-namespace OpenChart.UI.Actions
+namespace OpenChart.UI.MenuActions
 {
     /// <summary>
     /// An action that triggers the application to save the current project.
     /// </summary>
-    public class SaveAction : Actions.IAction
+    public class SaveAction : IMenuAction
     {
         IApplication app;
 

OpenChart/src/UI/Actions/File/SaveAsAction.cs → OpenChart/src/UI/MenuActions/File/SaveAsAction.cs

@@ -1,11 +1,11 @@
 using Serilog;
 
-namespace OpenChart.UI.Actions
+namespace OpenChart.UI.MenuActions
 {
     /// <summary>
     /// An action that triggers the application to save the current project.
     /// </summary>
-    public class SaveAsAction : Actions.IAction
+    public class SaveAsAction : IMenuAction
     {
         IApplication app;
 

OpenChart/src/UI/MenuActions/IMenuAction.cs

@@ -0,0 +1,33 @@
+namespace OpenChart.UI.MenuActions
+{
+    /// <summary>
+    /// An interface for a menu action. These are actions which are invoked through the app menu.
+    ///
+    /// Action instances are stored in <see cref="OpenChart.Application.ActionDict" /> and can
+    /// be retrieved by their name.
+    ///
+    /// For dynamic actions that need to respond to the state of the application (such as only
+    /// allowing the "Close Project" action to fire when a project is actually loaded), actions
+    /// should add event listener(s) to <see cref="OpenChart.Application.EventBus" /> and respond
+    /// to those events within the action class itself. Keeping all of the action-related code
+    /// inside the action classes makes it easy to find later on.
+    /// </summary>
+    public interface IMenuAction
+    {
+        /// <summary>
+        /// The GLib/Gtk action object.
+        /// </summary>
+        GLib.IAction Action { get; }
+
+        /// <summary>
+        /// The hotkey for the action.
+        /// </summary>
+        string GetHotkey();
+
+        /// <summary>
+        /// The name of the action. This is the name of the action referred to in
+        /// the code, not its display name. Display names are set in <see cref="OpenChart.UI.MenuActions.MenuModel" />
+        /// </summary>
+        string GetName();
+    }
+}

OpenChart/src/UI/Actions/MenuModel.cs → OpenChart/src/UI/MenuActions/MenuModel.cs

@@ -1,6 +1,6 @@
 using GLib;
 
-namespace OpenChart.UI.Actions
+namespace OpenChart.UI.MenuActions
 {
     /// <summary>
     /// The model/layout of the menu shown in the <see cref="OpenChart.UI.Widgets.MenuBar" /> widget.

OpenChart/src/UI/Windows/MainWindow.cs

@@ -1,6 +1,6 @@
 using Gtk;
 using ChartObjects = OpenChart.Charting.Objects;
-using OpenChart.UI.Actions;
+using OpenChart.UI.MenuActions;
 using OpenChart.UI.NoteField;
 
 namespace OpenChart.UI.Windows