source: branches/eraser6/6.0/Eraser/Settings.cs @ 1481

Revision 1481, 7.4 KB checked in by lowjoel, 5 years ago (diff)

Proper error message when we are unable to load a setting; the old one did not include the value we were reading.

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