Changeset 1983

Timestamp:

4/28/2010 8:52:58 AM (3 years ago)

Author:

lowjoel

Message:

Revised code to deal with settings. This version uses native types where possible to increase portability and ease of registry editing. It also deals with defaults.

Location:

trunk/eraser

Files:

• Eraser.DefaultPlugins/Plugin.cs (modified) (2 diffs)
• Eraser/Settings.cs (modified) (5 diffs)

trunk/eraser/Eraser.DefaultPlugins/Plugin.cs

@@ -111 +111 @@
             get
             {
-                return settings["FL16Method"] == null ? Guid.Empty :
-                    (Guid)settings["FL16Method"];
+                return settings.GetValue<Guid>("FL16Method");
             }
             set
             {
-                settings["FL16Method"] = value;
+                settings.SetValue("FL16Method", value);
             }
         }
@@ -127 +126 @@
             get
             {
-                return (Dictionary<Guid, CustomErasureMethod>)settings["EraseCustom"];
+                return settings.GetValue<Dictionary<Guid, CustomErasureMethod>>("EraseCustom");
             }
             set
             {
-                settings["EraseCustom"] = value;
+                settings.SetValue("EraseCustom", value);
             }
         }

trunk/eraser/Eraser/Settings.cs

@@ -81 +81 @@
             #endregion
 
-            public override object this[string setting]
-            {
-                get
-                {
-                    //Get the raw registry value
-                    object rawResult = Key.GetValue(setting, null);
-
-                    //Check if it is a serialised object
-                    byte[] resultArray = rawResult as byte[];
-                    if (resultArray != null)
+            public override T GetValue<T>(string name, T defaultValue)
+            {
+                //Get the raw registry value
+                object rawResult = key.GetValue(name, null);
+
+                //Check if it is a serialised object
+                byte[] resultArray = rawResult as byte[];
+                if (resultArray != null)
+                {
+                    using (MemoryStream stream = new MemoryStream(resultArray))
+                        try
+                        {
+                            BinaryFormatter formatter = new BinaryFormatter();
+                            if (typeof(T) != typeof(object))
+                                formatter.Binder = new TypeNameSerializationBinder(typeof(T));
+                            return (T)formatter.Deserialize(stream);
+                        }
+                        catch (SerializationException)
+                        {
+                            key.DeleteValue(name);
+                            MessageBox.Show(S._("Could not load the setting {0}\\{1} for " +
+                                    "plugin {2}. The setting has been lost.", key, name,
+                                    pluginID.ToString()),
+                                S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error,
+                                MessageBoxDefaultButton.Button1,
+                                S.IsRightToLeft(null) ? MessageBoxOptions.RtlReading : 0);
+                        }
+                }
+                else if (typeof(T) == typeof(Guid))
+                {
+                    return (T)(object)new Guid((string)rawResult);
+                }
+                else
+                {
+                    return (T)rawResult;
+                }
+
+                return defaultValue;
+            }
+
+            public override void SetValue(string name, object value)
+            {
+                if (value == null)
+                {
+                    key.DeleteValue(name);
+                }
+                else
+                {
+                    if (value is bool)
+                        key.SetValue(name, value, RegistryValueKind.DWord);
+                    else if ((value is int) || (value is uint))
+                        key.SetValue(name, value, RegistryValueKind.DWord);
+                    else if ((value is long) || (value is ulong))
+                        key.SetValue(name, value, RegistryValueKind.QWord);
+                    else if ((value is string) || (value is Guid))
+                        key.SetValue(name, value, RegistryValueKind.String);
+                    else if (value is ICollection<string>)
                     {
-                        using (MemoryStream stream = new MemoryStream(resultArray))
-                            try
-                            {
-                                return new BinaryFormatter().Deserialize(stream);
-                            }
-                            catch (SerializationException)
-                            {
-                                Key.DeleteValue(setting);
-                                MessageBox.Show(S._("Could not load the setting {0}\\{1} for " +
-                                        "plugin {2}. The setting has been lost.", Key, setting,
-                                        PluginID.ToString()),
-                                    S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error,
-                                    MessageBoxDefaultButton.Button1,
-                                    Localisation.IsRightToLeft(null) ?
-                                        MessageBoxOptions.RtlReading | MessageBoxOptions.RightAlign : 0);
-                            }
+                        ICollection<string> collection = (ICollection<string>)value;
+                        string[] temp = new string[collection.Count];
+                        collection.CopyTo(temp, 0);
+                        key.SetValue(name, temp, RegistryValueKind.MultiString);
                     }
                     else
-                    {
-                        return rawResult;
-                    }
-
-                    return null;
-                }
-                set
-                {
-                    if (value == null)
-                    {
-                        Key.DeleteValue(setting);
-                    }
-                    else
-                    {
-                        if (value is bool)
-                            Key.SetValue(setting, value, RegistryValueKind.DWord);
-                        else if ((value is int) || (value is uint))
-                            Key.SetValue(setting, value, RegistryValueKind.DWord);
-                        else if ((value is long) || (value is ulong))
-                            Key.SetValue(setting, value, RegistryValueKind.QWord);
-                        else if (value is string)
-                            Key.SetValue(setting, value, RegistryValueKind.String);
-                        else
-                            using (MemoryStream stream = new MemoryStream())
-                            {
-                                new BinaryFormatter().Serialize(stream, value);
-                                Key.SetValue(setting, stream.ToArray(), RegistryValueKind.Binary);
-                            }
-                    }
+                        using (MemoryStream stream = new MemoryStream())
+                        {
+                            new BinaryFormatter().Serialize(stream, value);
+                            key.SetValue(name, stream.ToArray(), RegistryValueKind.Binary);
+                        }
                 }
             }
@@ -211 +222 @@
             get
             {
-                return settings["Language"] == null ?
-                    GetCurrentCulture().Name :
-                    (string)settings["Language"];
+                return settings.GetValue("Language", GetCurrentCulture().Name);
             }
             set
             {
-                settings["Language"] = value;
+                settings.SetValue("Language", value);
             }
         }
@@ -228 +237 @@
             get
             {
-                return settings["IntegrateWithShell"] == null ?
-                    true : Convert.ToBoolean(settings["IntegrateWithShell"],
-                        CultureInfo.InvariantCulture);
+                return settings.GetValue("IntegrateWithShell", true);
             }
             set
             {
-                settings["IntegrateWithShell"] = value;
+                settings.SetValue("IntegrateWithShell", value);
             }
         }
@@ -246 +253 @@
             get
             {
-                return settings["HideWhenMinimised"] == null ?
-                    true : Convert.ToBoolean(settings["HideWhenMinimised"],
-                        CultureInfo.InvariantCulture);
+                return settings.GetValue("HideWhenMinimised", true);
             }
             set
             {
-                settings["HideWhenMinimised"] = value;
+                settings.SetValue("HideWhenMinimised", value);
             }
         }
@@ -264 +269 @@
             get
             {
-                return settings["ClearCompletedTasks"] == null ?
-                    true : Convert.ToBoolean(settings["ClearCompletedTasks"],
-                        CultureInfo.InvariantCulture);
+                return settings.GetValue("ClearCompletedTasks", true);
             }
             set
             {
-                settings["ClearCompletedTasks"] = value;
+                settings.SetValue("ClearCompletedTasks", value);
             }
         }