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

Revision 607, 6.9 KB checked in by lowjoel, 6 years ago (diff)

Make Executor subclasses implement IDisposable.

  • 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()
42        {
43            Application.EnableVisualStyles();
44            Application.SetCompatibleTextRenderingDefault(false);
45            Application.SafeTopLevelCaptionFormat = S._("Eraser");
46
47            using (ManagerLibrary library = new ManagerLibrary(new Settings()))
48            using (eraserClient = new DirectExecutor())
49            {
50                //Set our UI language
51                EraserSettings settings = new EraserSettings();
52                System.Threading.Thread.CurrentThread.CurrentUICulture =
53                    new CultureInfo(settings.Language);
54
55                //Load the task list
56                if (settings.TaskList != null)
57                    using (MemoryStream stream = new MemoryStream(settings.TaskList))
58                        try
59                        {
60                            eraserClient.LoadTaskList(stream);
61                        }
62                        catch (Exception)
63                        {
64                            settings.TaskList = null;
65                            MessageBox.Show(S._("Could not load task list. All task entries have " +
66                                "been lost."), S._("Eraser"), MessageBoxButtons.OK,
67                                MessageBoxIcon.Error);
68                        }
69
70                //Create the main form
71                MainForm form = new MainForm();
72
73                //Run tasks which are meant to be run on restart
74                int restartPos = Environment.CommandLine.ToLower().IndexOf("restart");
75                if ((restartPos > 1 &&
76                    Environment.CommandLine[restartPos - 1] == '/') ||
77                    (restartPos > 2 &&
78                    Environment.CommandLine[restartPos - 1] == '-' &&
79                    Environment.CommandLine[restartPos - 2] == '-'))
80                {
81                    eraserClient.QueueRestartTasks();
82                }
83
84                //Run the program
85                eraserClient.Run();
86                Application.Run(form);
87
88                //Save the task list
89                using (MemoryStream stream = new MemoryStream())
90                {
91                    eraserClient.SaveTaskList(stream);
92                    settings.TaskList = stream.ToArray();
93                }
94            }
95        }
96
97        /// <summary>
98        /// The global Executor instance.
99        /// </summary>
100        public static Executor eraserClient;
101    }
102
103    class Settings : Manager.SettingsManager
104    {
105        /// <summary>
106        /// Registry-based storage backing for the Settings class.
107        /// </summary>
108        private class RegistrySettings : Manager.Settings
109        {
110            /// <summary>
111            /// Constructor.
112            /// </summary>
113            /// <param name="key">The registry key to look for the settings in.</param>
114            public RegistrySettings(Guid pluginID, RegistryKey key)
115            {
116                this.key = key;
117            }
118
119            public override object this[string setting]
120            {
121                get
122                {
123                    byte[] currentSetting = (byte[])key.GetValue(setting, null);
124                    if (currentSetting != null && currentSetting.Length != 0)
125                        using (MemoryStream stream = new MemoryStream(currentSetting))
126                            try
127                            {
128                                return new BinaryFormatter().Deserialize(stream);
129                            }
130                            catch (Exception)
131                            {
132                                key.DeleteValue(setting);
133                                MessageBox.Show(S._("Could not load the setting {0} for plugin {1}. " +
134                                    "The setting has been lost.", key, pluginID.ToString()),
135                                    S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error);
136                            }
137
138                    return null;
139                }
140                set
141                {
142                    if (value == null)
143                    {
144                        key.DeleteValue(setting);
145                    }
146                    else
147                    {
148                        using (MemoryStream stream = new MemoryStream())
149                        {
150                            new BinaryFormatter().Serialize(stream, value);
151                            key.SetValue(setting, stream.ToArray(), RegistryValueKind.Binary);
152                        }
153                    }
154                }
155            }
156
157            /// <summary>
158            /// The GUID of the plugin whose settings this object is storing.
159            /// </summary>
160            private Guid pluginID;
161
162            /// <summary>
163            /// The registry key where the data is stored.
164            /// </summary>
165            private RegistryKey key;
166        }
167
168        public override void Save()
169        {
170        }
171
172        protected override Manager.Settings GetSettings(Guid guid)
173        {
174            //Open the registry key containing the settings
175            const string eraserKeyPath = @"SOFTWARE\Eraser\Eraser 6";
176            RegistryKey eraserKey = Registry.CurrentUser.OpenSubKey(eraserKeyPath, true);
177            if (eraserKey == null)
178                eraserKey = Registry.CurrentUser.CreateSubKey(eraserKeyPath);
179
180            RegistryKey pluginsKey = eraserKey.OpenSubKey(guid.ToString(), true);
181            if (pluginsKey == null)
182                pluginsKey = eraserKey.CreateSubKey(guid.ToString());
183
184            //Return the Settings object.
185            return new RegistrySettings(guid, pluginsKey);
186        }
187    }
188
189    internal class EraserSettings
190    {
191        public EraserSettings()
192        {
193            settings = Manager.ManagerLibrary.Instance.SettingsManager.ModuleSettings;
194        }
195
196        /// <summary>
197        /// Gets or sets the task list, serialised in binary form by the Manager assembly.
198        /// </summary>
199        public byte[] TaskList
200        {
201            get
202            {
203                return (byte[])settings["TaskList"];
204            }
205            set
206            {
207                settings["TaskList"] = value;
208            }
209        }
210
211        /// <summary>
212        /// Gets or sets the LCID of the language which the UI should be displayed in.
213        /// </summary>
214        public string Language
215        {
216            get
217            {
218                return settings["Language"] == null ? 
219                    GetCurrentCulture().Name :
220                    (string)settings["Language"];
221            }
222            set
223            {
224                settings["Language"] = value;
225            }
226        }
227
228        /// <summary>
229        /// Gets or sets a value on whether the main frame should be minimised to the
230        /// system notification area.
231        /// </summary>
232        public bool HideWhenMinimised
233        {
234            get
235            {
236                return settings["HideWhenMinimised"] == null ?
237                    true : (bool)settings["HideWhenMinimised"];
238            }
239            set
240            {
241                settings["HideWhenMinimised"] = value;
242            }
243        }
244
245        /// <summary>
246        /// Gets the current UI culture, correct to the top-level culture (i.e., English
247        /// instead of English (United Kingdom))
248        /// </summary>
249        /// <returns>The CultureInfo of the current UI culture, correct to the top level.</returns>
250        private static CultureInfo GetCurrentCulture()
251        {
252            CultureInfo culture = CultureInfo.CurrentUICulture;
253            while (culture.Parent != CultureInfo.InvariantCulture)
254                culture = culture.Parent;
255
256            return culture;
257        }
258
259        private Manager.Settings settings;
260    }
261}
Note: See TracBrowser for help on using the repository browser.