source: trunk/eraser6/Eraser/Settings.cs @ 1844

Revision 1844, 7.6 KB checked in by lowjoel, 4 years ago (diff)

The registry key provided to the RegistrySettings? class must not be null.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
Line 
1/*
2 * $Id$
3 * Copyright 2008-2010 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;
25using System.Text;
26
27using System.IO;
28using System.Globalization;
29using System.Runtime.Serialization;
30using System.Runtime.Serialization.Formatters.Binary;
31using Microsoft.Win32;
32
33using Eraser.Util;
34
35namespace Eraser
36{
37    internal class Settings : Manager.SettingsManager
38    {
39        /// <summary>
40        /// Registry-based storage backing for the Settings class.
41        /// </summary>
42        private sealed class RegistrySettings : Manager.Settings, IDisposable
43        {
44            /// <summary>
45            /// Constructor.
46            /// </summary>
47            /// <param name="pluginId">The GUID of the plugin for which settings are stored.</param>
48            /// <param name="key">The registry key to look for the settings in.</param>
49            public RegistrySettings(Guid pluginId, RegistryKey key)
50            {
51                if (key == null)
52                    throw new ArgumentNullException("key");
53
54                this.PluginID = pluginId;
55                this.Key = key;
56            }
57
58            #region IDisposable Members
59
60            ~RegistrySettings()
61            {
62                Dispose(false);
63            }
64
65            public void Dispose()
66            {
67                Dispose(true);
68                GC.SuppressFinalize(this);
69            }
70
71            private void Dispose(bool disposing)
72            {
73                if (Key == null)
74                    return;
75
76                if (disposing)
77                    Key.Close();
78                Key = null;
79            }
80
81            #endregion
82
83            public override object this[string setting]
84            {
85                get
86                {
87                    //Get the raw registry value
88                    object rawResult = Key.GetValue(setting, null);
89
90                    //Check if it is a serialised object
91                    byte[] resultArray = rawResult as byte[];
92                    if (resultArray != null)
93                    {
94                        using (MemoryStream stream = new MemoryStream(resultArray))
95                            try
96                            {
97                                return new BinaryFormatter().Deserialize(stream);
98                            }
99                            catch (SerializationException)
100                            {
101                                Key.DeleteValue(setting);
102                                MessageBox.Show(S._("Could not load the setting {0}\\{1} for " +
103                                        "plugin {2}. The setting has been lost.", Key, setting,
104                                        PluginID.ToString()),
105                                    S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error,
106                                    MessageBoxDefaultButton.Button1,
107                                    Localisation.IsRightToLeft(null) ?
108                                        MessageBoxOptions.RtlReading | MessageBoxOptions.RightAlign : 0);
109                            }
110                    }
111                    else
112                    {
113                        return rawResult;
114                    }
115
116                    return null;
117                }
118                set
119                {
120                    if (value == null)
121                    {
122                        Key.DeleteValue(setting);
123                    }
124                    else
125                    {
126                        if (value is bool)
127                            Key.SetValue(setting, value, RegistryValueKind.DWord);
128                        else if ((value is int) || (value is uint))
129                            Key.SetValue(setting, value, RegistryValueKind.DWord);
130                        else if ((value is long) || (value is ulong))
131                            Key.SetValue(setting, value, RegistryValueKind.QWord);
132                        else if (value is string)
133                            Key.SetValue(setting, value, RegistryValueKind.String);
134                        else
135                            using (MemoryStream stream = new MemoryStream())
136                            {
137                                new BinaryFormatter().Serialize(stream, value);
138                                Key.SetValue(setting, stream.ToArray(), RegistryValueKind.Binary);
139                            }
140                    }
141                }
142            }
143
144            /// <summary>
145            /// The GUID of the plugin whose settings this object is storing.
146            /// </summary>
147            private Guid PluginID;
148
149            /// <summary>
150            /// The registry key where the data is stored.
151            /// </summary>
152            private RegistryKey Key;
153        }
154
155        public override void Save()
156        {
157        }
158
159        protected override Manager.Settings GetSettings(Guid guid)
160        {
161            RegistryKey eraserKey = null;
162
163            try
164            {
165                //Open the registry key containing the settings
166                eraserKey = Registry.CurrentUser.OpenSubKey(Program.SettingsPath, true);
167                if (eraserKey == null)
168                    eraserKey = Registry.CurrentUser.CreateSubKey(Program.SettingsPath);
169
170                RegistryKey pluginsKey = eraserKey.OpenSubKey(guid.ToString(), true);
171                if (pluginsKey == null)
172                    pluginsKey = eraserKey.CreateSubKey(guid.ToString());
173
174                //Return the Settings object.
175                return new RegistrySettings(guid, pluginsKey);
176            }
177            finally
178            {
179                if (eraserKey != null)
180                    eraserKey.Close();
181            }
182        }
183    }
184
185    internal class EraserSettings
186    {
187        /// <summary>
188        /// Constructor.
189        /// </summary>
190        private EraserSettings()
191        {
192            settings = Manager.ManagerLibrary.Instance.SettingsManager.ModuleSettings;
193        }
194
195        /// <summary>
196        /// Gets the singleton instance of the Eraser UI Settings.
197        /// </summary>
198        /// <returns>The global instance of the Eraser UI settings.</returns>
199        public static EraserSettings Get()
200        {
201            if (instance == null)
202                instance = new EraserSettings();
203            return instance;
204        }
205
206        /// <summary>
207        /// Gets or sets the LCID of the language which the UI should be displayed in.
208        /// </summary>
209        public string Language
210        {
211            get
212            {
213                return settings["Language"] == null ?
214                    GetCurrentCulture().Name :
215                    (string)settings["Language"];
216            }
217            set
218            {
219                settings["Language"] = value;
220            }
221        }
222
223        /// <summary>
224        /// Gets or sets whether the Shell Extension should be loaded into Explorer.
225        /// </summary>
226        public bool IntegrateWithShell
227        {
228            get
229            {
230                return settings["IntegrateWithShell"] == null ?
231                    true : Convert.ToBoolean(settings["IntegrateWithShell"],
232                        CultureInfo.InvariantCulture);
233            }
234            set
235            {
236                settings["IntegrateWithShell"] = value;
237            }
238        }
239
240        /// <summary>
241        /// Gets or sets a value on whether the main frame should be minimised to the
242        /// system notification area.
243        /// </summary>
244        public bool HideWhenMinimised
245        {
246            get
247            {
248                return settings["HideWhenMinimised"] == null ?
249                    true : Convert.ToBoolean(settings["HideWhenMinimised"],
250                        CultureInfo.InvariantCulture);
251            }
252            set
253            {
254                settings["HideWhenMinimised"] = value;
255            }
256        }
257
258        /// <summary>
259        /// Gets ot setts a value whether tasks which were completed successfully
260        /// should be removed by the Eraser client.
261        /// </summary>
262        public bool ClearCompletedTasks
263        {
264            get
265            {
266                return settings["ClearCompletedTasks"] == null ?
267                    true : Convert.ToBoolean(settings["ClearCompletedTasks"],
268                        CultureInfo.InvariantCulture);
269            }
270            set
271            {
272                settings["ClearCompletedTasks"] = value;
273            }
274        }
275
276        /// <summary>
277        /// Gets the most specific UI culture with a localisation available, defaulting to English
278        /// if none exist.
279        /// </summary>
280        /// <returns>The CultureInfo of the current UI culture, correct to the top level.</returns>
281        private static CultureInfo GetCurrentCulture()
282        {
283            System.Reflection.Assembly entryAssembly = System.Reflection.Assembly.GetEntryAssembly();
284            CultureInfo culture = CultureInfo.CurrentUICulture;
285            while (culture.Parent != CultureInfo.InvariantCulture &&
286                !Localisation.LocalisationExists(culture, entryAssembly))
287            {
288                culture = culture.Parent;
289            }
290
291            //Default to English if any of our cultures don't exist.
292            if (!Localisation.LocalisationExists(culture, entryAssembly))
293                culture = new CultureInfo("en");
294
295            return culture;
296        }
297
298        /// <summary>
299        /// The data store behind the object.
300        /// </summary>
301        private Manager.Settings settings;
302
303        /// <summary>
304        /// The global instance of the settings class.
305        /// </summary>
306        private static EraserSettings instance;
307    }
308}
Note: See TracBrowser for help on using the repository browser.