Changeset 1983 for trunk/eraser


Ignore:
Timestamp:
4/28/2010 8:52:58 AM (5 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:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/eraser/Eraser.DefaultPlugins/Plugin.cs

    r1802 r1983  
    111111            get 
    112112            { 
    113                 return settings["FL16Method"] == null ? Guid.Empty : 
    114                     (Guid)settings["FL16Method"]; 
     113                return settings.GetValue<Guid>("FL16Method"); 
    115114            } 
    116115            set 
    117116            { 
    118                 settings["FL16Method"] = value; 
     117                settings.SetValue("FL16Method", value); 
    119118            } 
    120119        } 
     
    127126            get 
    128127            { 
    129                 return (Dictionary<Guid, CustomErasureMethod>)settings["EraseCustom"]; 
     128                return settings.GetValue<Dictionary<Guid, CustomErasureMethod>>("EraseCustom"); 
    130129            } 
    131130            set 
    132131            { 
    133                 settings["EraseCustom"] = value; 
     132                settings.SetValue("EraseCustom", value); 
    134133            } 
    135134        } 
  • trunk/eraser/Eraser/Settings.cs

    r1844 r1983  
    8181            #endregion 
    8282 
    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) 
     83            public override T GetValue<T>(string name, T defaultValue) 
     84            { 
     85                //Get the raw registry value 
     86                object rawResult = key.GetValue(name, null); 
     87 
     88                //Check if it is a serialised object 
     89                byte[] resultArray = rawResult as byte[]; 
     90                if (resultArray != null) 
     91                { 
     92                    using (MemoryStream stream = new MemoryStream(resultArray)) 
     93                        try 
     94                        { 
     95                            BinaryFormatter formatter = new BinaryFormatter(); 
     96                            if (typeof(T) != typeof(object)) 
     97                                formatter.Binder = new TypeNameSerializationBinder(typeof(T)); 
     98                            return (T)formatter.Deserialize(stream); 
     99                        } 
     100                        catch (SerializationException) 
     101                        { 
     102                            key.DeleteValue(name); 
     103                            MessageBox.Show(S._("Could not load the setting {0}\\{1} for " + 
     104                                    "plugin {2}. The setting has been lost.", key, name, 
     105                                    pluginID.ToString()), 
     106                                S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error, 
     107                                MessageBoxDefaultButton.Button1, 
     108                                S.IsRightToLeft(null) ? MessageBoxOptions.RtlReading : 0); 
     109                        } 
     110                } 
     111                else if (typeof(T) == typeof(Guid)) 
     112                { 
     113                    return (T)(object)new Guid((string)rawResult); 
     114                } 
     115                else 
     116                { 
     117                    return (T)rawResult; 
     118                } 
     119 
     120                return defaultValue; 
     121            } 
     122 
     123            public override void SetValue(string name, object value) 
     124            { 
     125                if (value == null) 
     126                { 
     127                    key.DeleteValue(name); 
     128                } 
     129                else 
     130                { 
     131                    if (value is bool) 
     132                        key.SetValue(name, value, RegistryValueKind.DWord); 
     133                    else if ((value is int) || (value is uint)) 
     134                        key.SetValue(name, value, RegistryValueKind.DWord); 
     135                    else if ((value is long) || (value is ulong)) 
     136                        key.SetValue(name, value, RegistryValueKind.QWord); 
     137                    else if ((value is string) || (value is Guid)) 
     138                        key.SetValue(name, value, RegistryValueKind.String); 
     139                    else if (value is ICollection<string>) 
    93140                    { 
    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                             } 
     141                        ICollection<string> collection = (ICollection<string>)value; 
     142                        string[] temp = new string[collection.Count]; 
     143                        collection.CopyTo(temp, 0); 
     144                        key.SetValue(name, temp, RegistryValueKind.MultiString); 
    110145                    } 
    111146                    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                     } 
     147                        using (MemoryStream stream = new MemoryStream()) 
     148                        { 
     149                            new BinaryFormatter().Serialize(stream, value); 
     150                            key.SetValue(name, stream.ToArray(), RegistryValueKind.Binary); 
     151                        } 
    141152                } 
    142153            } 
     
    211222            get 
    212223            { 
    213                 return settings["Language"] == null ? 
    214                     GetCurrentCulture().Name : 
    215                     (string)settings["Language"]; 
     224                return settings.GetValue("Language", GetCurrentCulture().Name); 
    216225            } 
    217226            set 
    218227            { 
    219                 settings["Language"] = value; 
     228                settings.SetValue("Language", value); 
    220229            } 
    221230        } 
     
    228237            get 
    229238            { 
    230                 return settings["IntegrateWithShell"] == null ? 
    231                     true : Convert.ToBoolean(settings["IntegrateWithShell"], 
    232                         CultureInfo.InvariantCulture); 
     239                return settings.GetValue("IntegrateWithShell", true); 
    233240            } 
    234241            set 
    235242            { 
    236                 settings["IntegrateWithShell"] = value; 
     243                settings.SetValue("IntegrateWithShell", value); 
    237244            } 
    238245        } 
     
    246253            get 
    247254            { 
    248                 return settings["HideWhenMinimised"] == null ? 
    249                     true : Convert.ToBoolean(settings["HideWhenMinimised"], 
    250                         CultureInfo.InvariantCulture); 
     255                return settings.GetValue("HideWhenMinimised", true); 
    251256            } 
    252257            set 
    253258            { 
    254                 settings["HideWhenMinimised"] = value; 
     259                settings.SetValue("HideWhenMinimised", value); 
    255260            } 
    256261        } 
     
    264269            get 
    265270            { 
    266                 return settings["ClearCompletedTasks"] == null ? 
    267                     true : Convert.ToBoolean(settings["ClearCompletedTasks"], 
    268                         CultureInfo.InvariantCulture); 
     271                return settings.GetValue("ClearCompletedTasks", true); 
    269272            } 
    270273            set 
    271274            { 
    272                 settings["ClearCompletedTasks"] = value; 
     275                settings.SetValue("ClearCompletedTasks", value); 
    273276            } 
    274277        } 
Note: See TracChangeset for help on using the changeset viewer.