source: branches/eraser6/Eraser/Program.cs @ 608

Revision 608, 7.1 KB checked in by lowjoel, 6 years ago (diff)

Implemented a branch at Main so that the same Eraser.exe can run both command line and GUI tasks

  • Property svn:keywords set to Id
Line 
1/*
2 * $Id$
3 * Copyright 2008 The Eraser Project
4 * Original Author: Joel Low <lowjoel@users.sourceforge.net>
5 * Modified By:
6 *
7 * This file is part of Eraser.
8 *
9 * Eraser is free software: you can redistribute it and/or modify it under the
10 * terms of the GNU General Public License as published by the Free Software
11 * Foundation, either version 3 of the License, or (at your option) any later
12 * version.
13 *
14 * Eraser is distributed in the hope that it will be useful, but WITHOUT ANY
15 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
16 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
17 *
18 * A copy of the GNU General Public License can be found at
19 * <http://www.gnu.org/licenses/>.
20 */
21
22using System;
23using System.Collections.Generic;
24using System.Windows.Forms;
25
26using Eraser.Manager;
27using Eraser.Util;
28using Microsoft.Win32;
29using System.IO;
30using System.Runtime.Serialization.Formatters.Binary;
31using System.Globalization;
32
33namespace Eraser
34{
35    static class Program
36    {
37        /// <summary>
38        /// The main entry point for the application.
39        /// </summary>
40        [STAThread]
41        static void Main(string[] commandLine)
42        {
43            if (commandLine.Length == 0)
44                GUIMain(false);
45            else if (commandLine.Length == 1)
46            {
47                if (commandLine[0].Substring(0, 1) == "/" ||
48                    commandLine[0].Substring(0, 2) == "--")
49                {
50                    GUIMain(true);
51                }
52                else
53                {
54                    CommandMain(commandLine);
55                }
56            }
57            else
58                CommandMain(commandLine);
59        }
60
61        private static void CommandMain(string[] commandLine)
62        {
63        }
64
65        private static void GUIMain(bool isRestart)
66        {
67            Application.EnableVisualStyles();
68            Application.SetCompatibleTextRenderingDefault(false);
69            Application.SafeTopLevelCaptionFormat = S._("Eraser");
70
71            using (ManagerLibrary library = new ManagerLibrary(new Settings()))
72            using (eraserClient = new DirectExecutor())
73            {
74                //Set our UI language
75                EraserSettings settings = new EraserSettings();
76                System.Threading.Thread.CurrentThread.CurrentUICulture =
77                    new CultureInfo(settings.Language);
78
79                //Load the task list
80                if (settings.TaskList != null)
81                    using (MemoryStream stream = new MemoryStream(settings.TaskList))
82                        try
83                        {
84                            eraserClient.LoadTaskList(stream);
85                        }
86                        catch (Exception)
87                        {
88                            settings.TaskList = null;
89                            MessageBox.Show(S._("Could not load task list. All task entries have " +
90                                "been lost."), S._("Eraser"), MessageBoxButtons.OK,
91                                MessageBoxIcon.Error);
92                        }
93
94                //Create the main form
95                MainForm form = new MainForm();
96
97                //Run tasks which are meant to be run on restart
98                if (isRestart)
99                {
100                    eraserClient.QueueRestartTasks();
101                }
102
103                //Run the program
104                eraserClient.Run();
105                Application.Run(form);
106
107                //Save the task list
108                using (MemoryStream stream = new MemoryStream())
109                {
110                    eraserClient.SaveTaskList(stream);
111                    settings.TaskList = stream.ToArray();
112                }
113            }
114        }
115
116        /// <summary>
117        /// The global Executor instance.
118        /// </summary>
119        public static Executor eraserClient;
120    }
121
122    class Settings : Manager.SettingsManager
123    {
124        /// <summary>
125        /// Registry-based storage backing for the Settings class.
126        /// </summary>
127        private class RegistrySettings : Manager.Settings
128        {
129            /// <summary>
130            /// Constructor.
131            /// </summary>
132            /// <param name="key">The registry key to look for the settings in.</param>
133            public RegistrySettings(Guid pluginID, RegistryKey key)
134            {
135                this.key = key;
136            }
137
138            public override object this[string setting]
139            {
140                get
141                {
142                    byte[] currentSetting = (byte[])key.GetValue(setting, null);
143                    if (currentSetting != null && currentSetting.Length != 0)
144                        using (MemoryStream stream = new MemoryStream(currentSetting))
145                            try
146                            {
147                                return new BinaryFormatter().Deserialize(stream);
148                            }
149                            catch (Exception)
150                            {
151                                key.DeleteValue(setting);
152                                MessageBox.Show(S._("Could not load the setting {0} for plugin {1}. " +
153                                    "The setting has been lost.", key, pluginID.ToString()),
154                                    S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error);
155                            }
156
157                    return null;
158                }
159                set
160                {
161                    if (value == null)
162                    {
163                        key.DeleteValue(setting);
164                    }
165                    else
166                    {
167                        using (MemoryStream stream = new MemoryStream())
168                        {
169                            new BinaryFormatter().Serialize(stream, value);
170                            key.SetValue(setting, stream.ToArray(), RegistryValueKind.Binary);
171                        }
172                    }
173                }
174            }
175
176            /// <summary>
177            /// The GUID of the plugin whose settings this object is storing.
178            /// </summary>
179            private Guid pluginID;
180
181            /// <summary>
182            /// The registry key where the data is stored.
183            /// </summary>
184            private RegistryKey key;
185        }
186
187        public override void Save()
188        {
189        }
190
191        protected override Manager.Settings GetSettings(Guid guid)
192        {
193            //Open the registry key containing the settings
194            const string eraserKeyPath = @"SOFTWARE\Eraser\Eraser 6";
195            RegistryKey eraserKey = Registry.CurrentUser.OpenSubKey(eraserKeyPath, true);
196            if (eraserKey == null)
197                eraserKey = Registry.CurrentUser.CreateSubKey(eraserKeyPath);
198
199            RegistryKey pluginsKey = eraserKey.OpenSubKey(guid.ToString(), true);
200            if (pluginsKey == null)
201                pluginsKey = eraserKey.CreateSubKey(guid.ToString());
202
203            //Return the Settings object.
204            return new RegistrySettings(guid, pluginsKey);
205        }
206    }
207
208    internal class EraserSettings
209    {
210        public EraserSettings()
211        {
212            settings = Manager.ManagerLibrary.Instance.SettingsManager.ModuleSettings;
213        }
214
215        /// <summary>
216        /// Gets or sets the task list, serialised in binary form by the Manager assembly.
217        /// </summary>
218        public byte[] TaskList
219        {
220            get
221            {
222                return (byte[])settings["TaskList"];
223            }
224            set
225            {
226                settings["TaskList"] = value;
227            }
228        }
229
230        /// <summary>
231        /// Gets or sets the LCID of the language which the UI should be displayed in.
232        /// </summary>
233        public string Language
234        {
235            get
236            {
237                return settings["Language"] == null ? 
238                    GetCurrentCulture().Name :
239                    (string)settings["Language"];
240            }
241            set
242            {
243                settings["Language"] = value;
244            }
245        }
246
247        /// <summary>
248        /// Gets or sets a value on whether the main frame should be minimised to the
249        /// system notification area.
250        /// </summary>
251        public bool HideWhenMinimised
252        {
253            get
254            {
255                return settings["HideWhenMinimised"] == null ?
256                    true : (bool)settings["HideWhenMinimised"];
257            }
258            set
259            {
260                settings["HideWhenMinimised"] = value;
261            }
262        }
263
264        /// <summary>
265        /// Gets the current UI culture, correct to the top-level culture (i.e., English
266        /// instead of English (United Kingdom))
267        /// </summary>
268        /// <returns>The CultureInfo of the current UI culture, correct to the top level.</returns>
269        private static CultureInfo GetCurrentCulture()
270        {
271            CultureInfo culture = CultureInfo.CurrentUICulture;
272            while (culture.Parent != CultureInfo.InvariantCulture)
273                culture = culture.Parent;
274
275            return culture;
276        }
277
278        private Manager.Settings settings;
279    }
280}
Note: See TracBrowser for help on using the repository browser.