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

Revision 562, 6.3 KB checked in by lowjoel, 6 years ago (diff)

-The EraserSettings? class should belong in Program.cs
-Defined a few defaults:

-File erasure method: Gutmann (35)
-Unused space: Pseudorandom (1)
-PRNG: RNGCryptoServiceProvider
-UI language: whatever the current UI culture is

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