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

Revision 412, 7.3 KB checked in by lowjoel, 6 years ago (diff)

Redesigned the Manager.Settings class.
-The plugin settings are no longer kept in a single dictionary; instead, they are distributed to be dealt with by the implementer of the Settings class. The GetSettings? and SetSettings? functions now are overloaded internally such that these values along with the plugins' GUID are sent together to the implementer class. The implementer class then stores it directly. This prevents unnecessary resource utilisation for large plugins and for plugins which are disabled
-This new design also allows for the serialisation and unserialisation of plugin settings which are non-primitive types, since the settings are loaded only on the initialisation of the plugin, not the initialisation of the settings object
-Created a SettingsChanged? event for classes to register callback functions to. This is useful when classes need to know when a setting is changed. Currently unimplemented though.
-Load is now a protected internal function which implementer classes must implement, this allows for the refreshing of settings whenever the program is running.

  • 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                Application.Run(form);
85
86                //Save the task list
87                using (MemoryStream stream = new MemoryStream())
88                {
89                    eraserClient.SaveTaskList(stream);
90                    key.SetValue("TaskList", stream.ToArray(), RegistryValueKind.Binary);
91                }
92            }
93        }
94
95        public static DirectExecutor eraserClient;
96    }
97
98    public class Settings : Manager.Settings
99    {
100        public Settings()
101        {
102            Load();
103        }
104
105        protected override void Load()
106        {
107            RegistryKey key = Application.UserAppDataRegistry;
108            ActivePRNG = new Guid((string)
109                key.GetValue("PRNG", Guid.Empty.ToString()));
110            EraseLockedFilesOnRestart =
111                (int)key.GetValue("EraseOnRestart", (object)1) != 0;
112            ConfirmEraseOnRestart =
113                (int)key.GetValue("ConfirmEraseOnRestart", (object)0) != 0;
114            DefaultFileErasureMethod = new Guid((string)
115                key.GetValue("DefaultFileErasureMethod", Guid.Empty.ToString()));
116            DefaultUnusedSpaceErasureMethod = new Guid((string)
117                key.GetValue("DefaultUnusedSpaceErasureMethod", Guid.Empty.ToString()));
118            ExecuteMissedTasksImmediately =
119                (int)key.GetValue("ExecuteMissedTasksImmediately", (object)1) != 0;
120            PlausibleDeniability =
121                (int)key.GetValue("PlausibleDeniability", (object)0) != 0;
122
123            UILanguage = (string)key.GetValue("UILanguage", CultureInfo.CurrentUICulture.Name);
124            System.Threading.Thread.CurrentThread.CurrentUICulture =
125                new CultureInfo(UILanguage);
126
127            //Load the plausible deniability files
128            byte[] plausibleDeniabilityFiles = (byte[])
129                key.GetValue("PlausibleDeniabilityFiles", new byte[0]);
130            if (plausibleDeniabilityFiles.Length != 0)
131                using (MemoryStream stream = new MemoryStream(plausibleDeniabilityFiles))
132                {
133                    try
134                    {
135                        this.PlausibleDeniabilityFiles = (List<string>)
136                            new BinaryFormatter().Deserialize(stream);
137                    }
138                    catch (Exception)
139                    {
140                        key.DeleteValue("PlausibleDeniabilityFiles");
141                        MessageBox.Show(S._("Could not load list of files used for plausible " +
142                            "deniability.\n\nThe list of files have been lost."),
143                            S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error);
144                    }
145                }
146
147            base.Load();
148        }
149
150        protected override void Save()
151        {
152            RegistryKey key = Application.UserAppDataRegistry;
153            key.SetValue("PRNG", ActivePRNG);
154            key.SetValue("EraseOnRestart", EraseLockedFilesOnRestart,
155                RegistryValueKind.DWord);
156            key.SetValue("ConfirmEraseOnRestart", ConfirmEraseOnRestart,
157                RegistryValueKind.DWord);
158            key.SetValue("DefaultFileErasureMethod", DefaultFileErasureMethod);
159            key.SetValue("DefaultUnusedSpaceErasureMethod",
160                DefaultUnusedSpaceErasureMethod);
161            key.SetValue("ExecuteMissedTasksImmediately",
162                ExecuteMissedTasksImmediately, RegistryValueKind.DWord);
163            key.SetValue("PlausibleDeniability", PlausibleDeniability,
164                RegistryValueKind.DWord);
165            key.SetValue("UILanguage", UILanguage);
166
167            using (MemoryStream stream = new MemoryStream())
168            {
169                new BinaryFormatter().Serialize(stream, PlausibleDeniabilityFiles);
170                key.SetValue("PlausibleDeniabilityFiles", stream.ToArray(), RegistryValueKind.Binary);
171            }
172        }
173
174        protected override Dictionary<string, object> GetSettings(Guid guid)
175        {
176            //Open the registry key containing the settings
177            RegistryKey pluginsKey = Application.UserAppDataRegistry.OpenSubKey(
178                "Plugins\\" + guid.ToString(), true);
179            Dictionary<string, object> result = new Dictionary<string, object>();
180
181            //Load every key/value pair into the dictionary
182            if (pluginsKey != null)
183                foreach (string key in pluginsKey.GetValueNames())
184                {
185                    byte[] currentSetting = (byte[])pluginsKey.GetValue(key, null);
186                    if (currentSetting.Length != 0)
187                        using (MemoryStream stream = new MemoryStream(currentSetting))
188                        {
189                            try
190                            {
191                                result[key] = new BinaryFormatter().Deserialize(stream);
192                            }
193                            catch (Exception)
194                            {
195                                pluginsKey.DeleteValue(key);
196                                MessageBox.Show(string.Format(S._("Could not load the setting {0} for plugin {1}." +
197                                    "The setting has been lost."), key, guid.ToString()),
198                                    S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error);
199                            }
200                        }
201                    else
202                        result[key] = null;
203                }
204
205            //We're done!
206            return result;
207        }
208
209        protected override void SetSettings(Guid guid, Dictionary<string, object> settings)
210        {
211            //Open the registry key containing the settings
212            RegistryKey pluginKey = Application.UserAppDataRegistry.OpenSubKey(
213                "Plugins\\" + guid.ToString(), true);
214            if (pluginKey == null)
215                pluginKey = Application.UserAppDataRegistry.CreateSubKey("Plugins\\" + guid.ToString());
216
217            foreach (string key in settings.Keys)
218            {
219                using (MemoryStream stream = new MemoryStream())
220                {
221                    new BinaryFormatter().Serialize(stream, settings[key]);
222                    pluginKey.SetValue(key, stream.ToArray(), RegistryValueKind.Binary);
223                }
224            }
225        }
226    }
227}
Note: See TracBrowser for help on using the repository browser.