Changeset 2509


Ignore:
Timestamp:
3/14/2012 5:45:46 AM (3 years ago)
Author:
lowjoel
Message:

Redesign the Eraser Plugin framework.

  • Split the plugin-dependent interfaces and related support classes out to Eraser.Plugins assembly
    • The extension interfaces are in the Eraser.Plugins.ExtensionPoints? namespace.
      • New IClientTool interface for plugins to create Eraser-hosted tools (e.g. #147)
    • The Registrars are in the Eraser.Plugins.Registrars namespace
    • Base types are now interfaces, no longer abstract base classes
    • Version the Eraser.plugins assembly differently from the rest of the project so that other plugins can target different versions of Eraser with the same assembly. Change the Eraser.Plugins assembly version only if there is an API change.
  • Plugin loading behaviour:
    • Core plugins will be loaded before the rest of the plugins, but they will be loaded only by assembly name and not by path
    • Non-core plugin loading is handled by the Manager Library and not the Plugin code
    • The PluginInstance? class is now the PluginInfo? class
    • There is no longer a need to indicate the default file and unused space erasure methods, PRNGs etc; they are now hardcoded to prevent plugins from changing defaults.
  • The separate command line for the Eraser shell extension has been removed.
    • The Erase on Restart menu item has been removed (since it is a scheduling option and should be set in the Task Properties Dialog)
  • Task Progress information is now pulled from the Eraser core instead of pushed via events.
  • New persistent store class to generalise the use of the old Settings class
  • IDragAndDropConfigurerFactory for transforming drag-and-drop operations to erasure targets. This removes the Eraser.exe assembly's dependency on Eraser.DefaultPlugins?.

Closes #363.

Location:
trunk/eraser
Files:
11 deleted
66 edited
7 copied

Legend:

Unmodified
Added
Removed
  • trunk/eraser

  • trunk/eraser/Eraser.BlackBox/BlackBox.cs

    r2323 r2509  
    4646using Eraser.Util; 
    4747using Eraser.Util.ExtensionMethods; 
    48 using ProgressChangedEventHandler = Eraser.Util.ProgressChangedEventHandler; 
    49 using ProgressChangedEventArgs = Eraser.Util.ProgressChangedEventArgs; 
     48using Eraser.Plugins; 
     49using ProgressChangedEventHandler = Eraser.Plugins.ProgressChangedEventHandler; 
     50using ProgressChangedEventArgs = Eraser.Plugins.ProgressChangedEventArgs; 
    5051 
    5152namespace Eraser.BlackBox 
  • trunk/eraser/Eraser.BlackBox/BlackBoxUploadForm.cs

    r1973 r2509  
    3030 
    3131using Eraser.Util; 
     32using Eraser.Plugins; 
    3233 
    3334using ProgressChangedEventArgs = System.ComponentModel.ProgressChangedEventArgs; 
    34 using EraserProgressChangedEventArgs = Eraser.Util.ProgressChangedEventArgs; 
     35using EraserProgressChangedEventArgs = Eraser.Plugins.ProgressChangedEventArgs; 
    3536 
    3637namespace Eraser.BlackBox 
  • trunk/eraser/Eraser.BlackBox/Eraser.BlackBox.csproj

    r2320 r2509  
    132132  </ItemGroup> 
    133133  <ItemGroup> 
    134     <ProjectReference Include="..\Eraser.Manager\Eraser.Manager.csproj"> 
    135       <Project>{C1AC3255-0939-499D-A69D-725E3DD4F574}</Project> 
    136       <Name>Eraser.Manager</Name> 
     134    <ProjectReference Include="..\Eraser.Plugins\Eraser.Plugins.csproj"> 
     135      <Project>{59F7ED0F-3589-4112-B612-4A9A6588F4A0}</Project> 
     136      <Name>Eraser.Plugins</Name> 
    137137      <Private>False</Private> 
    138138    </ProjectReference> 
  • trunk/eraser/Eraser.BlackBox/Plugin.cs

    r1981 r2509  
    2525using System.Windows.Forms; 
    2626 
    27 using Eraser.Manager.Plugin; 
     27using Eraser.Plugins; 
    2828 
    2929namespace Eraser.BlackBox 
     
    3131    public sealed class Plugin : IPlugin 
    3232    { 
    33         public void Initialize(Host host) 
     33        public void Initialize(PluginInfo info) 
    3434        { 
    3535            //Initialise our crash handler 
  • trunk/eraser/Eraser.BlackBox/Properties/AssemblyInfo.cs

    r1981 r2509  
    2626 
    2727// The plugin is an optional Eraser plugin, which should default to not load. 
    28 [assembly: Eraser.Manager.Plugin.LoadingPolicy(Eraser.Manager.Plugin.LoadingPolicy.DefaultOff)] 
     28[assembly: Eraser.Plugins.PluginLoadingPolicy(Eraser.Plugins.PluginLoadingPolicy.DefaultOff)] 
  • trunk/eraser/Eraser.DefaultPlugins/CustomMethodEditorForm.cs

    r1802 r2509  
    2828using System.Windows.Forms; 
    2929using System.Globalization; 
    30 using Eraser.Manager; 
     30 
    3131using Eraser.Util; 
     32using Eraser.Plugins; 
     33using Eraser.Plugins.ExtensionPoints; 
    3234 
    3335namespace Eraser.DefaultPlugins 
     
    9597                CultureInfo.CurrentCulture)); 
    9698            item.Tag = pass; 
    97             if (pass.Function == ErasureMethod.WriteRandom) 
     99            if (pass.Function == PassBasedErasureMethod.WriteRandom) 
    98100                item.SubItems.Add(S._("Random Data")); 
    99101            else 
     
    112114            if (passEditor.PassType == CustomMethodPassEditorPassType.Random) 
    113115            { 
    114                 pass.Function = ErasureMethod.WriteRandom; 
     116                pass.Function = PassBasedErasureMethod.WriteRandom; 
    115117                pass.OpaqueValue = null; 
    116118                item.SubItems[1].Text = S._("Random Data"); 
     
    118120            else 
    119121            { 
    120                 pass.Function = ErasureMethod.WriteConstant; 
     122                pass.Function = PassBasedErasureMethod.WriteConstant; 
    121123                pass.OpaqueValue = passEditor.PassData; 
    122124                item.SubItems[1].Text = S._("Constant ({0} bytes)", passEditor.PassData.Length); 
     
    133135            ErasureMethodPass pass = (ErasureMethodPass)item.Tag; 
    134136            passEditor.PassData = (byte[])pass.OpaqueValue; 
    135             passEditor.PassType = pass.Function == ErasureMethod.WriteRandom ? 
     137            passEditor.PassType = pass.Function == PassBasedErasureMethod.WriteRandom ? 
    136138                CustomMethodPassEditorPassType.Random : 
    137139                CustomMethodPassEditorPassType.Text; 
     
    163165 
    164166            //Then create a new, random pass, adding it to the list 
    165             ErasureMethodPass pass = new ErasureMethodPass(ErasureMethod.WriteRandom, null); 
     167            ErasureMethodPass pass = new ErasureMethodPass(PassBasedErasureMethod.WriteRandom, null); 
    166168            ListViewItem item = AddPass(pass); 
    167169 
  • trunk/eraser/Eraser.DefaultPlugins/EntropySources/KernelEntropySource.cs

    r2055 r2509  
    1 using System; 
     1/*  
     2 * $Id$ 
     3 * Copyright 2008-2012 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; 
    223using System.Collections.Generic; 
    324using System.Linq; 
     
    1031using Microsoft.Win32.SafeHandles; 
    1132 
    12 using Eraser.Manager; 
    1333using Eraser.Util; 
     34using Eraser.Plugins.ExtensionPoints; 
     35using System.Runtime.InteropServices; 
    1436 
    1537namespace Eraser.DefaultPlugins 
     
    2244    /// implemented as plugins, managed by EntropySourceManager. 
    2345    /// </summary> 
    24     public class KernelEntropySource : EntropySource 
     46    class KernelEntropySource : IEntropySource 
    2547    { 
    26         public override byte[] GetPrimer() 
     48        public byte[] GetPrimer() 
    2749        { 
    2850            List<byte> result = new List<byte>(); 
     
    3759        } 
    3860 
    39         public override Guid Guid 
     61        public Guid Guid 
    4062        { 
    4163            get 
     
    4567        } 
    4668 
    47         public override string Name 
     69        public string Name 
    4870        { 
    4971            get 
     
    5375        } 
    5476 
    55         public override byte[] GetEntropy() 
     77        public byte[] GetEntropy() 
    5678        { 
    5779            List<byte> result = new List<byte>(); 
     
    6587        /// Retrieves entropy from quick sources. 
    6688        /// </summary> 
    67         public override byte[] GetFastEntropy() 
     89        public byte[] GetFastEntropy() 
    6890        { 
    6991            List<byte> result = new List<byte>(); 
     
    145167        /// the FastAddEntropy function. 
    146168        /// </summary> 
    147         public override byte[] GetSlowEntropy() 
     169        public byte[] GetSlowEntropy() 
    148170        { 
    149171            List<byte> result = new List<byte>(); 
     
    174196            return result.ToArray(); 
    175197        } 
     198 
     199        /// <summary> 
     200        /// Converts value types into a byte array. This is a helper function to allow 
     201        /// inherited classes to convert value types into byte arrays which can be 
     202        /// returned to the EntropyPoller class. 
     203        /// </summary> 
     204        /// <typeparam name="T">Any value type</typeparam> 
     205        /// <param name="entropy">A value which will be XORed with pool contents.</param> 
     206        private static byte[] StructToBuffer<T>(T entropy) where T : struct 
     207        { 
     208            int sizeofObject = Marshal.SizeOf(entropy); 
     209            IntPtr memory = Marshal.AllocHGlobal(sizeofObject); 
     210            try 
     211            { 
     212                Marshal.StructureToPtr(entropy, memory, false); 
     213                byte[] dest = new byte[sizeofObject]; 
     214 
     215                //Copy the memory 
     216                Marshal.Copy(memory, dest, 0, sizeofObject); 
     217                return dest; 
     218            } 
     219            finally 
     220            { 
     221                Marshal.FreeHGlobal(memory); 
     222            } 
     223        } 
    176224    } 
    177225} 
  • trunk/eraser/Eraser.DefaultPlugins/Eraser.DefaultPlugins.csproj

    r2320 r2509  
    1515    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion> 
    1616    <RunPostBuildEvent>OnOutputUpdated</RunPostBuildEvent> 
     17    <IsWebBootstrapper>false</IsWebBootstrapper> 
     18    <TargetFrameworkProfile /> 
    1719    <PublishUrl>publish\</PublishUrl> 
    1820    <Install>true</Install> 
     
    2729    <ApplicationRevision>0</ApplicationRevision> 
    2830    <ApplicationVersion>1.0.0.%2a</ApplicationVersion> 
    29     <IsWebBootstrapper>false</IsWebBootstrapper> 
    3031    <UseApplicationTrust>false</UseApplicationTrust> 
    3132    <BootstrapperEnabled>true</BootstrapperEnabled> 
    32     <TargetFrameworkProfile /> 
    3333  </PropertyGroup> 
    3434  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> 
     
    7979    </Compile> 
    8080    <Compile Include="EntropySources\KernelEntropySource.cs" /> 
     81    <Compile Include="ErasureMethods\ErasureMethodBase.cs" /> 
    8182    <Compile Include="ErasureMethods\Custom.cs" /> 
    8283    <Compile Include="ErasureMethods\DoD.cs" /> 
     
    8990    <Compile Include="ErasureMethods\VSITR.cs" /> 
    9091    <Compile Include="ErasureMethods\RCMP_TSSIT_OPS_II.cs" /> 
     92    <Compile Include="ErasureTargets\ErasureTargetBase.cs" /> 
    9193    <Compile Include="ErasureTargets\FileErasureTarget.cs" /> 
    9294    <Compile Include="ErasureTargets\FileSystemObjectErasureTarget.cs" /> 
     
    127129      <DependentUpon>UnusedSpaceErasureTargetConfigurer.cs</DependentUpon> 
    128130    </Compile> 
     131    <Compile Include="FileSystems\FileSystemBase.cs" /> 
    129132    <Compile Include="FileSystems\Fat.cs" /> 
    130133    <Compile Include="FileSystems\Ntfs.cs" /> 
    131134    <Compile Include="FileSystems\Windows.cs" /> 
    132135    <Compile Include="Plugin.cs" /> 
     136    <Compile Include="Prngs\PrngBase.cs" /> 
    133137    <Compile Include="Properties\AssemblyInfo.cs" /> 
    134     <Compile Include="RNGCrypto.cs" /> 
     138    <Compile Include="Prngs\RNGCrypto.cs" /> 
    135139    <Compile Include="ErasureMethods\Schneier.cs" /> 
    136140    <Compile Include="SettingsForm.cs"> 
     
    143147  </ItemGroup> 
    144148  <ItemGroup> 
    145     <ProjectReference Include="..\Eraser.Manager\Eraser.Manager.csproj"> 
    146       <Project>{C1AC3255-0939-499D-A69D-725E3DD4F574}</Project> 
    147       <Name>Eraser.Manager</Name> 
     149    <ProjectReference Include="..\Eraser.Plugins\Eraser.Plugins.csproj"> 
     150      <Project>{59F7ED0F-3589-4112-B612-4A9A6588F4A0}</Project> 
     151      <Name>Eraser.Plugins</Name> 
    148152      <Private>False</Private> 
    149153    </ProjectReference> 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/Custom.cs

    r1802 r2509  
    2727 
    2828using Eraser.Util; 
    29 using Eraser.Manager; 
     29using Eraser.Plugins; 
     30using Eraser.Plugins.ExtensionPoints; 
    3031 
    3132namespace Eraser.DefaultPlugins 
     
    5657            { 
    5758                CustomErasureMethod method = methods[guid]; 
    58                 ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new EraseCustom(method)); 
     59                Host.Instance.ErasureMethods.Add(new EraseCustom(method)); 
    5960            } 
    6061        } 
     
    133134            public PassData(ErasureMethodPass pass) 
    134135            { 
    135                 if (pass.Function == ErasureMethod.WriteConstant) 
     136                if (pass.Function == PassBasedErasureMethod.WriteConstant) 
    136137                { 
    137138                    Random = false; 
    138139                    OpaqueValue = pass.OpaqueValue; 
    139140                } 
    140                 else if (pass.Function == ErasureMethod.WriteRandom) 
     141                else if (pass.Function == PassBasedErasureMethod.WriteRandom) 
    141142                { 
    142143                    Random = true; 
     
    150151            { 
    151152                return new ErasureMethodPass(pass.Random ? 
    152                     new ErasureMethodPassFunction(ErasureMethod.WriteRandom) : 
    153                         new ErasureMethodPassFunction(ErasureMethod.WriteConstant), 
     153                    new ErasureMethodPass.ErasureMethodPassFunction(PassBasedErasureMethod.WriteRandom) : 
     154                        new ErasureMethodPass.ErasureMethodPassFunction(PassBasedErasureMethod.WriteConstant), 
    154155                    pass.OpaqueValue); 
    155156            } 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/DoD.cs

    r1802 r2509  
    2525using System.Runtime.InteropServices; 
    2626 
    27 using Eraser.Manager; 
    2827using Eraser.Util; 
     28using Eraser.Plugins; 
     29using Eraser.Plugins.ExtensionPoints; 
    2930 
    3031namespace Eraser.DefaultPlugins 
     
    5354            { 
    5455                //Set passes 1, 4 and 5 to be a random value 
    55                 Prng prng = ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng]; 
     56                IPrng prng = Host.Instance.Prngs.ActivePrng; 
    5657                int rand = prng.Next(); 
    5758 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/FirstLast16KB.cs

    r2085 r2509  
    2525using System.Runtime.InteropServices; 
    2626 
    27 using Eraser.Manager; 
    28 using Eraser.Util; 
    2927using System.IO; 
    3028using System.Threading; 
    3129using System.Windows.Forms; 
    3230 
     31using Eraser.Util; 
     32using Eraser.Plugins; 
     33using Eraser.Plugins.ExtensionPoints; 
     34 
    3335namespace Eraser.DefaultPlugins 
    3436{ 
    3537    [Guid("0C2E07BF-0207-49a3-ADE8-46F9E1499C01")] 
    36     sealed class FirstLast16KB : ErasureMethod 
     38    sealed class FirstLast16KB : ErasureMethodBase 
    3739    { 
    3840        public FirstLast16KB() 
     
    4244                //Try to retrieve the set erasure method 
    4345                if (DefaultPlugin.Settings.FL16Method != Guid.Empty) 
    44                     method = ManagerLibrary.Instance.ErasureMethodRegistrar[ 
    45                         DefaultPlugin.Settings.FL16Method]; 
    46                 else if (ManagerLibrary.Settings.DefaultFileErasureMethod != Guid) 
    47                     method = ManagerLibrary.Instance.ErasureMethodRegistrar[ 
    48                         ManagerLibrary.Settings.DefaultFileErasureMethod]; 
     46                    method = Host.Instance.ErasureMethods[DefaultPlugin.Settings.FL16Method]; 
     47                else if (Host.Instance.Settings.DefaultFileErasureMethod != Guid) 
     48                    method = Host.Instance.ErasureMethods[ 
     49                        Host.Instance.Settings.DefaultFileErasureMethod]; 
    4950                else 
    50                     method = ManagerLibrary.Instance.ErasureMethodRegistrar[new Gutmann().Guid]; 
     51                    method = Host.Instance.ErasureMethods[new Gutmann().Guid]; 
    5152            } 
    5253            catch (ErasureMethodNotFoundException) 
     
    100101        } 
    101102 
    102         public override void Erase(Stream strm, long erasureLength, Prng prng, 
     103        public override void Erase(Stream strm, long erasureLength, IPrng prng, 
    103104            ErasureMethodProgressFunction callback) 
    104105        { 
     
    147148        private const long DataSize = 16 * 1024; 
    148149 
    149         private ErasureMethod method; 
     150        private IErasureMethod method; 
    150151    } 
    151152} 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/GOSTP50739.cs

    r1802 r2509  
    2828using System.Runtime.InteropServices; 
    2929 
    30 using Eraser.Manager; 
    3130using Eraser.Util; 
     31using Eraser.Plugins; 
     32using Eraser.Plugins.ExtensionPoints; 
    3233 
    3334namespace Eraser.DefaultPlugins 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/Gutmann.cs

    r2260 r2509  
    2828using System.Runtime.InteropServices; 
    2929 
    30 using Eraser.Manager; 
    3130using Eraser.Util; 
     31using Eraser.Plugins; 
     32using Eraser.Plugins.ExtensionPoints; 
    3233 
    3334namespace Eraser.DefaultPlugins 
    3435{ 
    35     [DefaultFileErasure(1)] 
    3636    [Guid("1407FC4E-FEFF-4375-B4FB-D7EFBB7E9922")] 
    3737    sealed class Gutmann : PassBasedErasureMethod 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/HMGIS5.cs

    r1802 r2509  
    2828using System.Runtime.InteropServices; 
    2929 
    30 using Eraser.Manager; 
    3130using Eraser.Util; 
     31using Eraser.Plugins; 
     32using Eraser.Plugins.ExtensionPoints; 
    3233 
    3334namespace Eraser.DefaultPlugins 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/RCMP_TSSIT_OPS_II.cs

    r1802 r2509  
    2828using System.Runtime.InteropServices; 
    2929 
    30 using Eraser.Manager; 
    3130using Eraser.Util; 
     31using Eraser.Plugins; 
     32using Eraser.Plugins.ExtensionPoints; 
    3233 
    3334namespace Eraser.DefaultPlugins 
     
    5556            get 
    5657            { 
    57                 Prng prng = ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng]; 
     58                IPrng prng = Host.Instance.Prngs.ActivePrng; 
    5859                int rand = prng.Next(); 
    5960 
    6061                return new ErasureMethodPass[] 
    6162                { 
    62                     new ErasureMethodPass(WriteConstant, new byte[] { (byte)0}), 
     63                    new ErasureMethodPass(WriteConstant, new byte[] { (byte)0 }), 
    6364                    new ErasureMethodPass(WriteConstant, new byte[] { (byte)0x01 }), 
    6465                    new ErasureMethodPass(WriteConstant, new byte[] { (byte)0 }), 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/Random.cs

    r1802 r2509  
    2525using System.Runtime.InteropServices; 
    2626 
    27 using Eraser.Manager; 
    2827using Eraser.Util; 
     28using Eraser.Plugins; 
     29using Eraser.Plugins.ExtensionPoints; 
    2930 
    3031namespace Eraser.DefaultPlugins 
    3132{ 
    32     [DefaultUnusedSpaceErasure(1)] 
    3333    [Guid("BF8BA267-231A-4085-9BF9-204DE65A6641")] 
    3434    sealed class Pseudorandom : PassBasedErasureMethod 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/Schneier.cs

    r1802 r2509  
    2525using System.Runtime.InteropServices; 
    2626 
    27 using Eraser.Manager; 
    2827using Eraser.Util; 
     28using Eraser.Plugins; 
     29using Eraser.Plugins.ExtensionPoints; 
    2930 
    3031namespace Eraser.DefaultPlugins 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/USAF5020.cs

    r1802 r2509  
    2828using System.Runtime.InteropServices; 
    2929 
    30 using Eraser.Manager; 
    3130using Eraser.Util; 
     31using Eraser.Plugins; 
     32using Eraser.Plugins.ExtensionPoints; 
    3233 
    3334namespace Eraser.DefaultPlugins 
     
    5556            get 
    5657            { 
    57                 Prng prng = ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng]; 
     58                IPrng prng = Host.Instance.Prngs.ActivePrng; 
    5859                int rand = prng.Next(); 
    5960 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/USArmyAR380_19.cs

    r1802 r2509  
    2828using System.Runtime.InteropServices; 
    2929 
    30 using Eraser.Manager; 
    3130using Eraser.Util; 
     31using Eraser.Plugins; 
     32using Eraser.Plugins.ExtensionPoints; 
    3233 
    3334namespace Eraser.DefaultPlugins 
     
    5556            get 
    5657            { 
    57                 Prng prng = ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng]; 
     58                IPrng prng = Host.Instance.Prngs.ActivePrng; 
    5859                int rand = prng.Next(); 
    5960 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureMethods/VSITR.cs

    r1802 r2509  
    2828using System.Runtime.InteropServices; 
    2929 
    30 using Eraser.Manager; 
    3130using Eraser.Util; 
     31using Eraser.Plugins; 
     32using Eraser.Plugins.ExtensionPoints; 
    3233 
    3334namespace Eraser.DefaultPlugins 
    3435{ 
    3536    [Guid("607632B2-651B-4935-883A-BDAA74FEBB54")] 
    36     class VSITR : PassBasedErasureMethod 
     37    sealed class VSITR : PassBasedErasureMethod 
    3738    { 
    3839        public override string Name 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/DriveErasureTarget.cs

    r2197 r2509  
    2727using System.Security.Permissions; 
    2828using System.Runtime.Serialization; 
    29  
    30 using Eraser.Manager; 
     29using System.IO; 
     30 
    3131using Eraser.Util; 
    3232using Eraser.Util.ExtensionMethods; 
    33 using System.IO; 
     33using Eraser.Plugins; 
     34using Eraser.Plugins.ExtensionPoints; 
     35using Eraser.Plugins.Registrars; 
    3436 
    3537namespace Eraser.DefaultPlugins 
     
    4042    [Serializable] 
    4143    [Guid("12CA079F-0B7A-48fa-B221-73AA217C1781")] 
    42     class DriveErasureTarget : ErasureTarget 
     44    class DriveErasureTarget : ErasureTargetBase 
    4345    { 
    4446        public DriveErasureTarget() 
     
    8082        } 
    8183 
    82         public override string UIText 
    83         { 
    84             get 
    85             { 
    86                 if (PhysicalDrive != null) 
    87                 { 
    88                     return S._("Hard disk {0}", PhysicalDrive.Index); 
    89                 } 
    90                 else if (Volume != null) 
    91                 { 
    92                     if (Volume.IsReady && Volume.IsMounted) 
    93                         return S._("Partition: {0}", Volume.MountPoints[0].GetDescription()); 
    94                     else if (Volume.IsReady && Volume.PhysicalDrive != null) 
    95                         return S._("Hard disk {0} Partition {1}", Volume.PhysicalDrive.Index, 
    96                             Volume.PhysicalDrive.Volumes.IndexOf(Volume) + 1); 
    97                     else 
    98                         return S._("Partition"); 
    99                 } 
     84        public override string ToString() 
     85        { 
     86            if (PhysicalDrive != null) 
     87            { 
     88                return S._("Hard disk {0}", PhysicalDrive.Index); 
     89            } 
     90            else if (Volume != null) 
     91            { 
     92                if (Volume.IsReady && Volume.IsMounted) 
     93                    return S._("Partition: {0}", Volume.MountPoints[0].GetDescription()); 
     94                else if (Volume.IsReady && Volume.PhysicalDrive != null) 
     95                    return S._("Hard disk {0} Partition {1}", Volume.PhysicalDrive.Index, 
     96                        Volume.PhysicalDrive.Volumes.IndexOf(Volume) + 1); 
    10097                else 
    101                     return null; 
    102             } 
     98                    return S._("Partition"); 
     99            } 
     100            else 
     101                return null; 
    103102        } 
    104103 
     
    108107        } 
    109108 
    110         public sealed override ErasureMethod EffectiveMethod 
     109        public sealed override IErasureMethod EffectiveMethod 
    111110        { 
    112111            get 
     
    115114                    return base.EffectiveMethod; 
    116115 
    117                 return ManagerLibrary.Instance.ErasureMethodRegistrar[ 
    118                     ManagerLibrary.Settings.DefaultUnusedSpaceErasureMethod]; 
     116                return Host.Instance.ErasureMethods[ 
     117                    Host.Instance.Settings.DefaultUnusedSpaceErasureMethod]; 
    119118            } 
    120119        } 
     
    179178            } 
    180179 
    181             Progress = new ProgressManager(); 
    182             Task.Progress.Steps.Add(new SteppedProgressManagerStep(Progress, 
    183                 1.0f / Task.Targets.Count)); 
     180            Progress = new SteppedProgressManager(); 
     181            ProgressManager stepProgress = new ProgressManager(); 
     182            Progress.Steps.Add(new SteppedProgressManagerStep(stepProgress, 1.0f, 
     183                ToString())); 
    184184            FileStream stream = null; 
    185185 
     
    187187            { 
    188188                //Overwrite the entire drive 
    189                 ErasureMethod method = EffectiveMethod; 
     189                IErasureMethod method = EffectiveMethod; 
    190190                if (Volume != null) 
    191191                { 
    192                     Progress.Total = Volume.TotalSize; 
     192                    stepProgress.Total = Volume.TotalSize; 
    193193                    stream = Volume.Open(FileAccess.ReadWrite, FileShare.ReadWrite); 
    194194                } 
    195195                else if (PhysicalDrive != null) 
    196196                { 
    197                     Progress.Total = PhysicalDrive.Size; 
     197                    stepProgress.Total = PhysicalDrive.Size; 
    198198                    PhysicalDrive.DeleteDriveLayout(); 
    199199                    stream = PhysicalDrive.Open(FileAccess.ReadWrite, FileShare.ReadWrite); 
     
    204204 
    205205                //Calculate the size of the erasure 
    206                 Progress.Total = method.CalculateEraseDataSize(null, Progress.Total); 
     206                stepProgress.Total = method.CalculateEraseDataSize(null, stepProgress.Total); 
    207207 
    208208                //Then run the erase task 
    209                 method.Erase(stream, long.MaxValue, 
    210                     ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng], 
     209                method.Erase(stream, long.MaxValue, Host.Instance.Prngs.ActivePrng, 
    211210                    delegate(long lastWritten, long totalData, int currentPass) 
    212211                    { 
    213                         Progress.Completed += lastWritten; 
    214                         OnProgressChanged(this, new ProgressChangedEventArgs(Progress, 
    215                             new TaskProgressChangedEventArgs(UIText, currentPass, method.Passes))); 
     212                        stepProgress.Completed += lastWritten; 
     213                        stepProgress.Tag = new int[] { currentPass, method.Passes }; 
    216214 
    217215                        if (Task.Canceled) 
     
    226224            } 
    227225        } 
    228  
    229         /// <summary> 
    230         /// The Progress manager for this target. 
    231         /// </summary> 
    232         private new ProgressManager Progress 
    233         { 
    234             get 
    235             { 
    236                 return (ProgressManager)base.Progress; 
    237             } 
    238             set 
    239             { 
    240                 base.Progress = value; 
    241             } 
    242         } 
    243226    } 
    244227} 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/DriveErasureTargetConfigurer.cs

    r2232 r2509  
    3030using System.IO; 
    3131using System.Text.RegularExpressions; 
    32  
    33 using Eraser.Manager; 
     32using System.Globalization; 
     33 
    3434using Eraser.Util; 
    3535using Eraser.Util.ExtensionMethods; 
    36 using System.Globalization; 
     36using Eraser.Plugins; 
     37using Eraser.Plugins.ExtensionPoints; 
    3738 
    3839namespace Eraser.DefaultPlugins 
     
    234235        #region IConfigurer<ErasureTarget> Members 
    235236 
    236         public void LoadFrom(ErasureTarget target) 
     237        public void LoadFrom(IErasureTarget target) 
    237238        { 
    238239            DriveErasureTarget partition = target as DriveErasureTarget; 
     
    251252        } 
    252253 
    253         public bool SaveTo(ErasureTarget target) 
     254        public bool SaveTo(IErasureTarget target) 
    254255        { 
    255256            DriveErasureTarget partition = target as DriveErasureTarget; 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FileErasureTarget.cs

    r2106 r2509  
    2929using System.IO; 
    3030 
    31 using Eraser.Manager; 
    3231using Eraser.Util; 
     32using Eraser.Plugins; 
     33using Eraser.Plugins.ExtensionPoints; 
    3334 
    3435namespace Eraser.DefaultPlugins 
     
    3940    [Serializable] 
    4041    [Guid("0D741505-E1C4-400d-8470-598AF35E174D")] 
    41     public class FileErasureTarget : FileSystemObjectErasureTarget 
     42    class FileErasureTarget : FileSystemObjectErasureTarget 
    4243    { 
    4344        #region Serialization code 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FileErasureTargetConfigurer.cs

    r2237 r2509  
    3030 
    3131using System.Text.RegularExpressions; 
     32using System.IO; 
    3233 
    33 using Eraser.Manager; 
    3434using Eraser.Util; 
    35 using System.IO; 
     35using Eraser.Plugins; 
     36using Eraser.Plugins.ExtensionPoints; 
    3637 
    3738namespace Eraser.DefaultPlugins 
    3839{ 
    39     public partial class FileErasureTargetConfigurer : UserControl, IErasureTargetConfigurer 
     40    public partial class FileErasureTargetConfigurer : UserControl, 
     41        IErasureTargetConfigurer, IDragAndDropConfigurerFactory<IErasureTarget> 
    4042    { 
    4143        public FileErasureTargetConfigurer() 
     
    4749        #region IConfigurer<ErasureTarget> Members 
    4850 
    49         public void LoadFrom(ErasureTarget target) 
     51        public void LoadFrom(IErasureTarget target) 
    5052        { 
    5153            FileErasureTarget file = target as FileErasureTarget; 
     
    5759        } 
    5860 
    59         public bool SaveTo(ErasureTarget target) 
     61        public bool SaveTo(IErasureTarget target) 
    6062        { 
    6163            FileErasureTarget file = target as FileErasureTarget; 
     
    113115        #endregion 
    114116 
     117        #region IDragAndDropConfigurer<IErasureTarget> Members 
     118 
     119        public ICollection<IErasureTarget> ProcessArgument(DragEventArgs e) 
     120        { 
     121            List<string> files = e.Data.GetDataPresent(DataFormats.FileDrop) ? 
     122                new List<string>((string[])e.Data.GetData(DataFormats.FileDrop, false)) : 
     123                new List<string>(); 
     124 
     125            List<IErasureTarget> result = new List<IErasureTarget>(); 
     126            foreach (string file in files) 
     127            { 
     128                if (Directory.Exists(file)) 
     129                { 
     130                    FolderErasureTarget target = new FolderErasureTarget(); 
     131                    target.Path = file; 
     132                    result.Add(target); 
     133                } 
     134            } 
     135 
     136            return result; 
     137        } 
     138 
     139        #endregion 
     140 
    115141        private void fileBrowse_Click(object sender, EventArgs e) 
    116142        { 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FileSystemObjectErasureTarget.cs

    r2337 r2509  
    3030using System.IO; 
    3131 
    32 using Eraser.Manager; 
    3332using Eraser.Util; 
    3433using Eraser.Util.ExtensionMethods; 
     34using Eraser.Plugins; 
     35using Eraser.Plugins.ExtensionPoints; 
     36using Eraser.Plugins.Registrars; 
    3537 
    3638namespace Eraser.DefaultPlugins 
     
    4042    /// </summary> 
    4143    [Serializable] 
    42     public abstract class FileSystemObjectErasureTarget : ErasureTarget 
     44    abstract class FileSystemObjectErasureTarget : ErasureTargetBase 
    4345    { 
    4446        #region Serialization code 
     
    132134            { 
    133135                //The system cannot open the file, try to force the file handle to close. 
    134                 if (!ManagerLibrary.Settings.ForceUnlockLockedFiles) 
     136                if (!Host.Instance.Settings.ForceUnlockLockedFiles) 
    135137                    throw; 
    136138 
     
    172174        public string Path { get; set; } 
    173175 
    174         public sealed override ErasureMethod EffectiveMethod 
     176        public sealed override IErasureMethod EffectiveMethod 
    175177        { 
    176178            get 
     
    179181                    return base.EffectiveMethod; 
    180182 
    181                 return ManagerLibrary.Instance.ErasureMethodRegistrar[ 
    182                     ManagerLibrary.Settings.DefaultFileErasureMethod]; 
    183             } 
    184         } 
    185  
    186         public override string UIText 
    187         { 
    188             get 
    189             { 
    190                 return Path; 
    191             } 
     183                return Host.Instance.ErasureMethods[ 
     184                    Host.Instance.Settings.DefaultFileErasureMethod]; 
     185            } 
     186        } 
     187 
     188        public override string ToString() 
     189        { 
     190            return Path; 
    192191        } 
    193192 
     
    206205            if (Progress == null) 
    207206                throw new InvalidOperationException("The Progress property must not be null."); 
    208             Task.Progress.Steps.Add(new SteppedProgressManagerStep(Progress, 
    209                 1.0f / Task.Targets.Count)); 
    210207 
    211208            //Iterate over every path, and erase the path. 
    212209            for (int i = 0; i < paths.Count; ++i) 
    213210            { 
     211                //Does the file still exist after our enumeration? 
     212                if (!paths[i].Exists) 
     213                    continue; 
     214 
     215                //Create a new progress manager for the file. 
    214216                ProgressManager step = new ProgressManager(); 
    215217                Progress.Steps.Add(new SteppedProgressManagerStep(step, 
    216218                    dataTotal == 0 ? 0.0f : paths[i].Length / (float)dataTotal, 
    217                     S._("Erasing files..."))); 
     219                    paths[i].FullName)); 
    218220                EraseStream(paths[i], step); 
    219                 step.MarkComplete(); 
    220221            } 
    221222        } 
     
    239240 
    240241            //Get the filesystem provider to handle the secure file erasures 
    241             FileSystem fsManager = ManagerLibrary.Instance.FileSystemRegistrar[ 
     242            IFileSystem fsManager = Host.Instance.FileSystems[ 
    242243                VolumeInfo.FromMountPoint(info.DirectoryName)]; 
    243244 
     
    247248            { 
    248249                //Update the task progress 
    249                 ErasureMethod method = EffectiveMethod; 
    250                 OnProgressChanged(this, new ProgressChangedEventArgs(progress, 
    251                     new TaskProgressChangedEventArgs(info.FullName, 0, method.Passes))); 
    252  
     250                IErasureMethod method = EffectiveMethod; 
     251                 
    253252                //Remove the read-only flag, if it is set. 
    254253                if (isReadOnly = info.IsReadOnly) 
     
    262261                            throw new OperationCanceledException(S._("The task was cancelled.")); 
    263262 
     263                        progress.Tag = new int[] { currentPass, method.Passes }; 
    264264                        progress.Total = totalData; 
    265265                        progress.Completed += lastWritten; 
    266                         OnProgressChanged(this, new ProgressChangedEventArgs(progress, 
    267                             new TaskProgressChangedEventArgs(info.FullName, currentPass, method.Passes))); 
    268266                    }; 
    269267 
     
    301299        /// <param name="info">The stream to erase.</param> 
    302300        /// <param name="callback">The erasure progress callback.</param> 
    303         private void TryEraseStream(FileSystem fsManager, ErasureMethod method, StreamInfo info, 
     301        private void TryEraseStream(IFileSystem fsManager, IErasureMethod method, StreamInfo info, 
    304302            ErasureMethodProgressFunction callback) 
    305303        { 
     
    332330                catch (SharingViolationException) 
    333331                { 
    334                     if (!ManagerLibrary.Settings.ForceUnlockLockedFiles) 
     332                    if (!Host.Instance.Settings.ForceUnlockLockedFiles) 
    335333                        throw; 
    336334 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FolderErasureTarget.cs

    r2222 r2509  
    3131using System.IO; 
    3232 
    33 using Eraser.Manager; 
    3433using Eraser.Util; 
     34using Eraser.Plugins; 
     35using Eraser.Plugins.ExtensionPoints; 
    3536 
    3637namespace Eraser.DefaultPlugins 
     
    4142    [Serializable] 
    4243    [Guid("F50B0A44-3AB1-4cab-B81E-1713AC3D28C9")] 
    43     public class FolderErasureTarget : FileSystemObjectErasureTarget 
     44    class FolderErasureTarget : FileSystemObjectErasureTarget 
    4445    { 
    4546        #region Serialization code 
     
    199200                    directory.GetFiles("*", SearchOption.AllDirectories).Length == 0) 
    200201                { 
    201                     FileSystem fsManager = ManagerLibrary.Instance.FileSystemRegistrar[ 
     202                    IFileSystem fsManager = Host.Instance.FileSystems[ 
    202203                        VolumeInfo.FromMountPoint(Path)]; 
    203                     fsManager.DeleteFolder(directory); 
     204                    fsManager.DeleteFolder(directory, true); 
    204205                } 
    205206            } 
     
    218219 
    219220            //Public progress updates. 
    220             OnProgressChanged(this, new ProgressChangedEventArgs(progress, 
    221                 new TaskProgressChangedEventArgs(info.FullName, 0, 0))); 
     221            progress.Tag = info.FullName; 
    222222 
    223223            //Ensure that the current directory is empty before deleting. 
     
    227227                try 
    228228                { 
    229                     ManagerLibrary.Instance.FileSystemRegistrar[ 
    230                         VolumeInfo.FromMountPoint(Path)].DeleteFolder(info); 
     229                    Host.Instance.FileSystems[VolumeInfo.FromMountPoint(Path)]. 
     230                        DeleteFolder(info, true); 
    231231                } 
    232232                catch (UnauthorizedAccessException) 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FolderErasureTargetConfigurer.cs

    r2237 r2509  
    2929using System.Windows.Forms; 
    3030 
     31using System.IO; 
    3132using System.Text.RegularExpressions; 
    3233 
    33 using Eraser.Manager; 
    3434using Eraser.Util; 
    35 using System.IO; 
     35using Eraser.Plugins; 
     36using Eraser.Plugins.ExtensionPoints; 
    3637 
    3738namespace Eraser.DefaultPlugins 
    3839{ 
    39     public partial class FolderErasureTargetConfigurer : UserControl, IErasureTargetConfigurer 
     40    public partial class FolderErasureTargetConfigurer : UserControl, 
     41        IErasureTargetConfigurer, IDragAndDropConfigurerFactory<IErasureTarget> 
    4042    { 
    4143        public FolderErasureTargetConfigurer() 
     
    4749        #region IConfigurer<ErasureTarget> Members 
    4850 
    49         public void LoadFrom(ErasureTarget target) 
     51        public void LoadFrom(IErasureTarget target) 
    5052        { 
    5153            FolderErasureTarget folder = target as FolderErasureTarget; 
     
    6062        } 
    6163 
    62         public bool SaveTo(ErasureTarget target) 
     64        public bool SaveTo(IErasureTarget target) 
    6365        { 
    6466            FolderErasureTarget folder = target as FolderErasureTarget; 
     
    143145        #endregion 
    144146 
     147        #region IDragAndDropConfigurer<IErasureTarget> Members 
     148 
     149        public ICollection<IErasureTarget> ProcessArgument(DragEventArgs e) 
     150        { 
     151            List<string> files = e.Data.GetDataPresent(DataFormats.FileDrop) ? 
     152                new List<string>((string[])e.Data.GetData(DataFormats.FileDrop, false)) : 
     153                new List<string>(); 
     154 
     155            List<IErasureTarget> result = new List<IErasureTarget>(); 
     156            foreach (string file in files) 
     157            { 
     158                if (File.Exists(file)) 
     159                { 
     160                    FileErasureTarget target = new FileErasureTarget(); 
     161                    target.Path = file; 
     162                    result.Add(target); 
     163                } 
     164            } 
     165 
     166            return result; 
     167        } 
     168 
     169        #endregion 
     170 
    145171        private void folderBrowse_Click(object sender, EventArgs e) 
    146172        { 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/RecycleBinErasureTarget.cs

    r2144 r2509  
    2929using System.IO; 
    3030 
    31 using Eraser.Manager; 
    3231using Eraser.Util; 
     32using Eraser.Plugins; 
     33using Eraser.Plugins.ExtensionPoints; 
    3334 
    3435namespace Eraser.DefaultPlugins 
     
    3637    [Serializable] 
    3738    [Guid("A1FA7354-0258-4903-88E9-0D31FC5F8D51")] 
    38     public class RecycleBinErasureTarget : FileSystemObjectErasureTarget 
     39    class RecycleBinErasureTarget : FileSystemObjectErasureTarget 
    3940    { 
    4041        #region Serialization code 
     
    6263        /// Retrieves the text to display representing this task. 
    6364        /// </summary> 
    64         public override string UIText 
     65        public override string ToString() 
    6566        { 
    66             get 
    67             { 
    68                 return S._("Recycle Bin"); 
    69             } 
     67            return S._("Recycle Bin"); 
    7068        } 
    7169 
     
    132130            Progress.Steps.Add(new SteppedProgressManagerStep(progress, 
    133131                0.0f, S._("Emptying recycle bin..."))); 
    134             OnProgressChanged(this, new ProgressChangedEventArgs(progress, 
    135                 new TaskProgressChangedEventArgs(string.Empty, 0, 0))); 
    136132 
    137133            RecycleBin.Empty(EmptyRecycleBinOptions.NoConfirmation | 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/RecycleBinErasureTargetConfigurer.cs

    r2232 r2509  
    2525using System.Text; 
    2626using System.Text.RegularExpressions; 
     27using System.IO; 
    2728 
    28 using Eraser.Manager; 
    2929using Eraser.Util; 
     30using Eraser.Plugins; 
     31using Eraser.Plugins.ExtensionPoints; 
    3032 
    3133namespace Eraser.DefaultPlugins 
    3234{ 
    33     class RecycleBinErasureTargetConfigurer : IErasureTargetConfigurer 
     35    class RecycleBinErasureTargetConfigurer : IErasureTargetConfigurer, 
     36        IDragAndDropConfigurerFactory<IErasureTarget> 
    3437    { 
    3538        #region IConfigurer<ErasureTarget> Members 
    3639 
    37         public void LoadFrom(ErasureTarget target) 
     40        public void LoadFrom(IErasureTarget target) 
    3841        { 
    3942        } 
    4043 
    41         public bool SaveTo(ErasureTarget target) 
     44        public bool SaveTo(IErasureTarget target) 
    4245        { 
    4346            return true; 
     
    6871 
    6972        #endregion 
     73 
     74        #region IDragAndDropConfigurer<IErasureTarget> Members 
     75 
     76        public ICollection<IErasureTarget> ProcessArgument(System.Windows.Forms.DragEventArgs e) 
     77        { 
     78            //Then try to see if we have shell locations dropped on us. 
     79            if (e.Data.GetDataPresent("Shell IDList Array")) 
     80            { 
     81                MemoryStream stream = (MemoryStream)e.Data.GetData("Shell IDList Array"); 
     82                byte[] buffer = new byte[stream.Length]; 
     83                stream.Read(buffer, 0, buffer.Length); 
     84                ShellCIDA cida = new ShellCIDA(buffer); 
     85 
     86                if (cida.cidl > 0) 
     87                { 
     88                    for (int i = 1; i <= cida.cidl; ++i) 
     89                    { 
     90                        if (cida.aoffset[i].Guid == Shell.KnownFolderIDs.RecycleBin)                             
     91                        { 
     92                            return new IErasureTarget[] { new RecycleBinErasureTarget() }; 
     93                        } 
     94                    } 
     95                } 
     96            } 
     97 
     98            return new IErasureTarget[0]; 
     99        } 
     100 
     101        #endregion 
    70102    } 
    71103} 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/SecureMoveErasureTarget.cs

    r2322 r2509  
    3030using System.IO; 
    3131 
    32 using Eraser.Manager; 
    3332using Eraser.Util; 
    3433using Eraser.Util.ExtensionMethods; 
     34using Eraser.Plugins; 
     35using Eraser.Plugins.ExtensionPoints; 
    3536 
    3637namespace Eraser.DefaultPlugins 
     
    4142    [Serializable] 
    4243    [Guid("18FB3523-4012-4718-8B9A-BADAA9084214")] 
    43     public class SecureMoveErasureTarget : FileSystemObjectErasureTarget 
     44    class SecureMoveErasureTarget : FileSystemObjectErasureTarget 
    4445    { 
    4546        #region Serialization code 
     
    7273        } 
    7374 
    74         public override string UIText 
    75         { 
    76             get { return S._("Securely move {0}", Path); } 
     75        public override string ToString() 
     76        { 
     77            return S._("Securely move {0}", Path); 
    7778        } 
    7879 
     
    123124            //Create the progress manager. 
    124125            Progress = new SteppedProgressManager(); 
    125             Task.Progress.Steps.Add(new SteppedProgressManagerStep(Progress, 
    126                 1.0f / Task.Targets.Count)); 
    127  
     126             
    128127            try 
    129128            { 
     
    235234 
    236235                //Update progress. 
    237                 OnProgressChanged(this, new ProgressChangedEventArgs(folderDeleteProgress, 
    238                     new TaskProgressChangedEventArgs(subDirectory.FullName, 1, 1))); 
     236                folderDeleteProgress.Tag = subDirectory.FullName; 
    239237 
    240238                //Get the directory which we copied to and copy the file times to the 
     
    247245 
    248246                //Then delete the source directory. 
    249                 FileSystem fsManager = ManagerLibrary.Instance.FileSystemRegistrar[ 
     247                IFileSystem fsManager = Host.Instance.FileSystems[ 
    250248                    VolumeInfo.FromMountPoint(Path)]; 
    251                 fsManager.DeleteFolder(subDirectory); 
     249                fsManager.DeleteFolder(subDirectory, true); 
    252250            }; 
    253251            CopyTimesAndDelete(info); 
     
    341339            progress.Completed = TotalBytesTransferred; 
    342340            progress.Total = TotalFileSize; 
    343             OnProgressChanged(this, new ProgressChangedEventArgs(Progress, 
    344                 new TaskProgressChangedEventArgs(file.FullName, 1, 1))); 
     341            progress.Tag = file.FullName; 
    345342 
    346343            if (Task.Canceled) 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/SecureMoveErasureTargetConfigurer.cs

    r2232 r2509  
    3131using System.Text.RegularExpressions; 
    3232 
    33 using Eraser.Manager; 
    3433using Eraser.Util; 
     34using Eraser.Plugins; 
     35using Eraser.Plugins.ExtensionPoints; 
    3536 
    3637namespace Eraser.DefaultPlugins 
     
    4647        #region IConfigurer<ErasureTarget> Members 
    4748 
    48         public void LoadFrom(ErasureTarget target) 
     49        public void LoadFrom(IErasureTarget target) 
    4950        { 
    5051            SecureMoveErasureTarget secureMove = target as SecureMoveErasureTarget; 
     
    6162        } 
    6263 
    63         public bool SaveTo(ErasureTarget target) 
     64        public bool SaveTo(IErasureTarget target) 
    6465        { 
    6566            SecureMoveErasureTarget secureMove = target as SecureMoveErasureTarget; 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/UnusedSpaceErasureTarget.cs

    r2323 r2509  
    3030using System.IO; 
    3131 
    32 using Eraser.Manager; 
    3332using Eraser.Util; 
    3433using Eraser.Util.ExtensionMethods; 
     34using Eraser.Plugins; 
     35using Eraser.Plugins.ExtensionPoints; 
     36using Eraser.Plugins.Registrars; 
    3537 
    3638namespace Eraser.DefaultPlugins 
     
    4143    [Serializable] 
    4244    [Guid("A627BEC4-CAFC-46ce-92AD-209157C3177A")] 
    43     public class UnusedSpaceErasureTarget : ErasureTarget 
     45    class UnusedSpaceErasureTarget : ErasureTargetBase 
    4446    { 
    4547        #region Serialization code 
     
    7375        } 
    7476 
     77        public override string ToString() 
     78        { 
     79            return S._("Unused disk space ({0})", Drive); 
     80        } 
     81 
    7582        public override string Name 
    7683        { 
     
    7885        } 
    7986 
    80         public sealed override ErasureMethod EffectiveMethod 
     87        public sealed override IErasureMethod EffectiveMethod 
    8188        { 
    8289            get 
     
    8592                    return base.EffectiveMethod; 
    8693 
    87                 return ManagerLibrary.Instance.ErasureMethodRegistrar[ 
    88                     ManagerLibrary.Settings.DefaultUnusedSpaceErasureMethod]; 
    89             } 
    90         } 
    91  
    92         public override bool SupportsMethod(ErasureMethod method) 
     94                return Host.Instance.ErasureMethods[ 
     95                    Host.Instance.Settings.DefaultUnusedSpaceErasureMethod]; 
     96            } 
     97        } 
     98 
     99        public override bool SupportsMethod(IErasureMethod method) 
    93100        { 
    94101            return method == ErasureMethodRegistrar.Default || 
    95                 method is UnusedSpaceErasureMethod; 
     102                method is IUnusedSpaceErasureMethod; 
    96103        } 
    97104 
     
    111118        } 
    112119 
    113         public override string UIText 
    114         { 
    115             get { return S._("Unused disk space ({0})", Drive); } 
    116         } 
    117  
    118120        public override IErasureTargetConfigurer Configurer 
    119121        { 
     
    169171 
    170172            //Get the erasure method if the user specified he wants the default. 
    171             ErasureMethod method = EffectiveMethod; 
     173            IErasureMethod method = EffectiveMethod; 
    172174 
    173175            //Make a folder to dump our temporary files in 
    174176            DirectoryInfo info = new DirectoryInfo(Drive); 
    175177            VolumeInfo volInfo = VolumeInfo.FromMountPoint(Drive); 
    176             FileSystem fsManager = ManagerLibrary.Instance.FileSystemRegistrar[volInfo]; 
     178            IFileSystem fsManager = Host.Instance.FileSystems[volInfo]; 
    177179 
    178180            //Start sampling the speed of the task. 
    179181            Progress = new SteppedProgressManager(); 
    180             Task.Progress.Steps.Add(new SteppedProgressManagerStep( 
    181                 Progress, 1.0f / Task.Targets.Count)); 
    182182 
    183183            //Erase the cluster tips of every file on the drive. 
     
    194194                        throw new OperationCanceledException(S._("The task was cancelled.")); 
    195195 
    196                     OnProgressChanged(this, new ProgressChangedEventArgs(tipSearch, 
    197                         new TaskProgressChangedEventArgs(path, 0, 0))); 
     196                    tipSearch.Tag = path; 
    198197                }; 
    199198 
     
    207206                        tipProgress.Total = totalFiles; 
    208207                        tipProgress.Completed = currentFile; 
    209                         OnProgressChanged(this, new ProgressChangedEventArgs(tipProgress, 
    210                             new TaskProgressChangedEventArgs(currentFilePath, 0, 0))); 
     208                        tipProgress.Tag = currentFilePath; 
    211209 
    212210                        if (Task.Canceled) 
     
    222220            bool lowDiskSpaceNotifications = Shell.LowDiskSpaceNotificationsEnabled; 
    223221            info = info.CreateSubdirectory(Path.GetFileName( 
    224                 FileSystem.GenerateRandomFileName(info, 18))); 
     222                FileSystemBase.GenerateRandomFileName(info, 18))); 
    225223            try 
    226224            { 
     
    245243                        residentProgress.Completed = currentFile; 
    246244                        residentProgress.Total = totalFiles; 
    247                         OnProgressChanged(this, new ProgressChangedEventArgs(residentProgress, 
    248                             new TaskProgressChangedEventArgs(string.Empty, 0, 0))); 
    249245 
    250246                        if (Task.Canceled) 
     
    261257                Progress.Steps.Add(new SteppedProgressManagerStep(tempFiles, 
    262258                    0.0f, S._("Removing temporary files..."))); 
    263                 OnProgressChanged(this, new ProgressChangedEventArgs(tempFiles, 
    264                     new TaskProgressChangedEventArgs(string.Empty, 0, 0))); 
    265259                info.Delete(true); 
    266260                tempFiles.MarkComplete(); 
     
    283277                    structureProgress.Total = totalFiles; 
    284278                    structureProgress.Completed = currentFile; 
    285  
    286                     //Set the event parameters, then broadcast the progress event. 
    287                     OnProgressChanged(this, new ProgressChangedEventArgs(structureProgress, 
    288                         new TaskProgressChangedEventArgs(string.Empty, 0, 0))); 
    289279                } 
    290280            ); 
     
    294284        } 
    295285 
    296         private void EraseUnusedSpace(VolumeInfo volInfo, DirectoryInfo info, FileSystem fsInfo, 
    297             ErasureMethod method) 
     286        private void EraseUnusedSpace(VolumeInfo volInfo, DirectoryInfo info, IFileSystem fsInfo, 
     287            IErasureMethod method) 
    298288        { 
    299289            ProgressManager mainProgress = new ProgressManager(); 
     
    305295            { 
    306296                //Generate a non-existant file name 
    307                 string currFile = FileSystem.GenerateRandomFileName(info, 18); 
     297                string currFile = FileSystemBase.GenerateRandomFileName(info, 18); 
    308298 
    309299                //Create the stream 
     
    316306                    mainProgress.Total = mainProgress.Completed + 
    317307                        method.CalculateEraseDataSize(null, volInfo.AvailableFreeSpace); 
    318                     long streamLength = Math.Min(ErasureMethod.FreeSpaceFileUnit, 
     308                    long streamLength = Math.Min(PassBasedErasureMethod.FreeSpaceFileUnit, 
    319309                        volInfo.AvailableFreeSpace); 
    320310 
     
    336326 
    337327                    //Then run the erase task 
    338                     method.Erase(stream, long.MaxValue, 
    339                         ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng], 
     328                    method.Erase(stream, long.MaxValue, Host.Instance.Prngs.ActivePrng, 
    340329                        delegate(long lastWritten, long totalData, int currentPass) 
    341330                        { 
    342331                            mainProgress.Completed += lastWritten; 
    343                             OnProgressChanged(this, new ProgressChangedEventArgs(mainProgress, 
    344                                 new TaskProgressChangedEventArgs(Drive, currentPass, method.Passes))); 
     332                            mainProgress.Tag = new int[] { currentPass, method.Passes }; 
    345333 
    346334                            if (Task.Canceled) 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/UnusedSpaceErasureTargetConfigurer.cs

    r2232 r2509  
    3232using System.Text.RegularExpressions; 
    3333 
    34 using Eraser.Manager; 
    3534using Eraser.Util; 
    3635using Eraser.Util.ExtensionMethods; 
     36using Eraser.Plugins; 
     37using Eraser.Plugins.ExtensionPoints; 
    3738 
    3839namespace Eraser.DefaultPlugins 
     
    99100        #region IConfigurer<ErasureTarget> Members 
    100101 
    101         public void LoadFrom(ErasureTarget target) 
     102        public void LoadFrom(IErasureTarget target) 
    102103        { 
    103104            UnusedSpaceErasureTarget unused = target as UnusedSpaceErasureTarget; 
     
    112113        } 
    113114 
    114         public bool SaveTo(ErasureTarget target) 
     115        public bool SaveTo(IErasureTarget target) 
    115116        { 
    116117            UnusedSpaceErasureTarget unused = target as UnusedSpaceErasureTarget; 
  • trunk/eraser/Eraser.DefaultPlugins/FileSystems/Fat.cs

    r2189 r2509  
    2626 
    2727using System.IO; 
    28 using Eraser.Manager; 
     28 
    2929using Eraser.Util; 
     30using Eraser.Plugins; 
     31using Eraser.Plugins.ExtensionPoints; 
    3032 
    3133namespace Eraser.DefaultPlugins 
     
    3436    /// Provides functions to handle erasures specific to FAT volumes. 
    3537    /// </summary> 
    36     public abstract class FatFileSystem : WindowsFileSystem 
     38    abstract class FatFileSystem : WindowsFileSystem 
    3739    { 
    3840        public override void EraseOldFileSystemResidentFiles(VolumeInfo volume, 
    39             DirectoryInfo tempDirectory, ErasureMethod method, 
     41            DirectoryInfo tempDirectory, IErasureMethod method, 
    4042            FileSystemEntriesEraseProgress callback) 
    4143        { 
     
    4345        } 
    4446 
    45         public override void EraseFileSystemObject(StreamInfo info, ErasureMethod method, 
     47        public override void EraseFileSystemObject(StreamInfo info, IErasureMethod method, 
    4648            ErasureMethodProgressFunction callback) 
    4749        { 
     
    6062                { 
    6163                    //Then erase the file. 
    62                     method.Erase(strm, long.MaxValue, 
    63                         ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng], 
    64                         callback 
    65                     ); 
     64                    method.Erase(strm, long.MaxValue, Host.Instance.Prngs.ActivePrng, callback); 
    6665                } 
    6766 
     
    137136 
    138137    [Guid("36C78D78-7EE4-4304-8068-10755651AF2D")] 
    139     public class Fat12FileSystem : FatFileSystem 
     138    class Fat12FileSystem : FatFileSystem 
    140139    { 
    141140        public override Guid Guid 
     
    156155 
    157156    [Guid("8C9DF746-1CD6-435d-8D04-3FE40A0A1C83")] 
    158     public class Fat16FileSystem : FatFileSystem 
     157    class Fat16FileSystem : FatFileSystem 
    159158    { 
    160159        public override Guid Guid 
     
    175174 
    176175    [Guid("1FCD66DC-179D-4402-8FF8-D19F74A4C398")] 
    177     public class Fat32FileSystem : FatFileSystem 
     176    class Fat32FileSystem : FatFileSystem 
    178177    { 
    179178        public override Guid Guid 
  • trunk/eraser/Eraser.DefaultPlugins/FileSystems/Ntfs.cs

    r2162 r2509  
    2626 
    2727using System.IO; 
    28 using Eraser.Manager; 
     28 
    2929using Eraser.Util; 
     30using Eraser.Plugins; 
     31using Eraser.Plugins.ExtensionPoints; 
    3032 
    3133namespace Eraser.DefaultPlugins 
     
    3537    /// </summary> 
    3638    [Guid("34399F62-0AD4-411c-8C71-5E1E6213545C")] 
    37     public class NtfsFileSystem : WindowsFileSystem 
     39    class NtfsFileSystem : WindowsFileSystem 
    3840    { 
    3941        public override Guid Guid 
     
    4850 
    4951        public override void EraseOldFileSystemResidentFiles(VolumeInfo volume, 
    50             DirectoryInfo tempDirectory, ErasureMethod method, 
     52            DirectoryInfo tempDirectory, IErasureMethod method, 
    5153            FileSystemEntriesEraseProgress callback) 
    5254        { 
     
    6971 
    7072                        //Then run the erase task 
    71                         method.Erase(strm, long.MaxValue, ManagerLibrary.Instance.PrngRegistrar[ 
    72                                 ManagerLibrary.Settings.ActivePrng], null); 
     73                        method.Erase(strm, long.MaxValue, Host.Instance.Prngs.ActivePrng, null); 
    7374 
    7475                        //Call the callback function if one is provided. We'll provide a dummy 
     
    102103        { 
    103104            //Create a directory to hold all the temporary files 
    104             DirectoryInfo tempDir = new DirectoryInfo(FileSystem.GenerateRandomFileName( 
     105            DirectoryInfo tempDir = new DirectoryInfo(GenerateRandomFileName( 
    105106                info.MountPoints[0], 32)); 
    106107            tempDir.Create(); 
     
    152153                } 
    153154 
    154                 DeleteFolder(tempDir); 
    155             } 
    156         } 
    157  
    158         public override void EraseFileSystemObject(StreamInfo info, ErasureMethod method, 
     155                DeleteFolder(tempDir, true); 
     156            } 
     157        } 
     158 
     159        public override void EraseFileSystemObject(StreamInfo info, IErasureMethod method, 
    159160            ErasureMethodProgressFunction callback) 
    160161        { 
     
    168169                    FileShare.None)) 
    169170                { 
    170                     method.Erase(strm, long.MaxValue, 
    171                         ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng], 
     171                    method.Erase(strm, long.MaxValue, Host.Instance.Prngs.ActivePrng, 
    172172                        null); 
    173173                } 
     
    190190 
    191191                //Then erase the file. 
    192                 method.Erase(strm, long.MaxValue, 
    193                     ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng], 
    194                     callback 
    195                 ); 
     192                method.Erase(strm, long.MaxValue, Host.Instance.Prngs.ActivePrng, callback); 
    196193 
    197194                //Set the length of the file to 0. 
  • trunk/eraser/Eraser.DefaultPlugins/FileSystems/Windows.cs

    r2309 r2509  
    2727using System.IO; 
    2828using System.Threading; 
    29 using Eraser.Manager; 
     29 
    3030using Eraser.Util; 
    3131using Eraser.Util.ExtensionMethods; 
     32using Eraser.Plugins; 
     33using Eraser.Plugins.ExtensionPoints; 
    3234 
    3335namespace Eraser.DefaultPlugins 
     
    3638    /// Base class for all Windows filesystems. 
    3739    /// </summary> 
    38     public abstract class WindowsFileSystem : FileSystem 
     40    abstract class WindowsFileSystem : FileSystemBase 
    3941    { 
    4042        public override void ResetFileTimes(FileSystemInfo info) 
     
    4850            //If the user wants plausible deniability, find a random file from the 
    4951            //list of decoys and write it over. 
    50             if (Manager.ManagerLibrary.Settings.PlausibleDeniability) 
     52            if (Host.Instance.Settings.PlausibleDeniability) 
    5153            { 
    5254                using (FileStream fileStream = info.OpenWrite()) 
     
    6668            { 
    6769                foreach (DirectoryInfo dir in info.GetDirectories()) 
    68                     DeleteFolder(dir); 
     70                    DeleteFolder(dir, true); 
    6971                foreach (FileInfo file in info.GetFiles()) 
    7072                    DeleteFile(file); 
     
    131133                                //Try to force the handle closed. 
    132134                                if (tries > FileNameEraseTries + 1 || 
    133                                     !ManagerLibrary.Settings.ForceUnlockLockedFiles) 
     135                                    !Host.Instance.Settings.ForceUnlockLockedFiles) 
    134136                                { 
    135137                                    throw new IOException(S._("The file {0} is currently in use " + 
     
    210212        } 
    211213 
    212         public override void EraseClusterTips(VolumeInfo info, ErasureMethod method, 
     214 
     215        /// <summary> 
     216        /// Writes a file for plausible deniability over the current stream. 
     217        /// </summary> 
     218        /// <param name="stream">The stream to write the data to.</param> 
     219        private static void CopyPlausibleDeniabilityFile(Stream stream) 
     220        { 
     221            //Get the template file to copy 
     222            FileInfo shadowFileInfo; 
     223            { 
     224                string shadowFile = null; 
     225                List<string> entries = new List<string>( 
     226                    Host.Instance.Settings.PlausibleDeniabilityFiles); 
     227                IPrng prng = Host.Instance.Prngs.ActivePrng; 
     228                do 
     229                { 
     230                    if (entries.Count == 0) 
     231                        throw new FatalException(S._("Plausible deniability was selected, " + 
     232                            "but no decoy files were found. The current file has been only " + 
     233                            "replaced with random data.")); 
     234 
     235                    //Get an item from the list of files, and then check that the item exists. 
     236                    int index = prng.Next(entries.Count - 1); 
     237                    shadowFile = entries[index]; 
     238                    if (File.Exists(shadowFile) || Directory.Exists(shadowFile)) 
     239                    { 
     240                        if ((File.GetAttributes(shadowFile) & FileAttributes.Directory) != 0) 
     241                        { 
     242                            DirectoryInfo dir = new DirectoryInfo(shadowFile); 
     243                            FileInfo[] files = dir.GetFiles("*", SearchOption.AllDirectories); 
     244                            entries.Capacity += files.Length; 
     245                            foreach (FileInfo f in files) 
     246                                entries.Add(f.FullName); 
     247                        } 
     248                        else 
     249                            shadowFile = entries[index]; 
     250                    } 
     251                    else 
     252                        shadowFile = null; 
     253 
     254                    entries.RemoveAt(index); 
     255                } 
     256                while (string.IsNullOrEmpty(shadowFile)); 
     257                shadowFileInfo = new FileInfo(shadowFile); 
     258            } 
     259 
     260            //Dump the copy (the first 4MB, or less, depending on the file size and size of 
     261            //the original file) 
     262            long amountToCopy = Math.Min(stream.Length, 
     263                Math.Min(4 * 1024 * 1024, shadowFileInfo.Length)); 
     264            using (FileStream shadowFileStream = shadowFileInfo.OpenRead()) 
     265            { 
     266                while (stream.Position < amountToCopy) 
     267                { 
     268                    byte[] buf = new byte[524288]; 
     269                    int bytesRead = shadowFileStream.Read(buf, 0, buf.Length); 
     270 
     271                    //Stop bothering if the input stream is at the end 
     272                    if (bytesRead == 0) 
     273                        break; 
     274 
     275                    //Dump the read contents onto the file to be deleted 
     276                    stream.Write(buf, 0, 
     277                        (int)Math.Min(bytesRead, amountToCopy - stream.Position)); 
     278                } 
     279            } 
     280        } 
     281 
     282        public override void EraseClusterTips(VolumeInfo info, IErasureMethod method, 
    213283            ClusterTipsSearchProgress searchCallback, ClusterTipsEraseProgress eraseCallback) 
    214284        { 
     
    323393        /// <param name="stream">The stream to erase.</param> 
    324394        /// <param name="method">The erasure method to use.</param> 
    325         private void EraseFileClusterTips(StreamInfo streamInfo, ErasureMethod method) 
     395        private void EraseFileClusterTips(StreamInfo streamInfo, IErasureMethod method) 
    326396        { 
    327397            //Get the file access times 
     
    355425 
    356426                    //Erase the file 
    357                     method.Erase(stream, long.MaxValue, ManagerLibrary.Instance.PrngRegistrar[ 
    358                             ManagerLibrary.Settings.ActivePrng], null); 
     427                    method.Erase(stream, long.MaxValue, Host.Instance.Prngs.ActivePrng, null); 
    359428                } 
    360429                finally 
  • trunk/eraser/Eraser.DefaultPlugins/Plugin.cs

    r2260 r2509  
    2525using System.Windows.Forms; 
    2626 
    27 using Eraser.Manager; 
    28 using Eraser.Manager.Plugin; 
     27using Eraser.Plugins; 
    2928using Eraser.Util; 
    3029 
     
    3332    public sealed class DefaultPlugin : IPlugin 
    3433    { 
    35         public void Initialize(Host host) 
     34        public void Initialize(PluginInfo info) 
    3635        { 
    37             Settings = new DefaultPluginSettings(); 
     36            Settings = new DefaultPluginSettings(info.PersistentStore); 
    3837 
    3938            //Then register the erasure methods et al. 
    40             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new Gutmann());              //35 passes 
    41             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new DoD_EcE());              //7 passes 
    42             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new RCMP_TSSIT_OPS_II());    //7 passes 
    43             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new Schneier());             //7 passes 
    44             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new VSITR());                //7 passes 
    45             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new DoD_E());                //3 passes 
    46             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new HMGIS5Enhanced());       //3 passes 
    47             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new USAF5020());             //3 passes 
    48             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new USArmyAR380_19());       //3 passes 
    49             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new GOSTP50739());           //2 passes 
    50             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new HMGIS5Baseline());       //1 pass 
    51             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new Pseudorandom());         //1 pass 
     39            Host.Instance.ErasureMethods.Add(new Gutmann());            //35 passes 
     40            Host.Instance.ErasureMethods.Add(new DoD_EcE());            //7 passes 
     41            Host.Instance.ErasureMethods.Add(new RCMP_TSSIT_OPS_II());  //7 passes 
     42            Host.Instance.ErasureMethods.Add(new Schneier());           //7 passes 
     43            Host.Instance.ErasureMethods.Add(new VSITR());              //7 passes 
     44            Host.Instance.ErasureMethods.Add(new DoD_E());              //3 passes 
     45            Host.Instance.ErasureMethods.Add(new HMGIS5Enhanced());     //3 passes 
     46            Host.Instance.ErasureMethods.Add(new USAF5020());           //3 passes 
     47            Host.Instance.ErasureMethods.Add(new USArmyAR380_19());     //3 passes 
     48            Host.Instance.ErasureMethods.Add(new GOSTP50739());         //2 passes 
     49            Host.Instance.ErasureMethods.Add(new HMGIS5Baseline());     //1 pass 
     50            Host.Instance.ErasureMethods.Add(new Pseudorandom());       //1 pass 
    5251            EraseCustom.RegisterAll(); 
    53             ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new FirstLast16KB()); 
     52            Host.Instance.ErasureMethods.Add(new FirstLast16KB()); 
    5453 
    55             ManagerLibrary.Instance.PrngRegistrar.Add(new RngCrypto()); 
     54            Host.Instance.Prngs.Add(new RngCrypto()); 
    5655 
    57             ManagerLibrary.Instance.EntropySourceRegistrar.Add(new KernelEntropySource()); 
     56            Host.Instance.EntropySources.Add(new KernelEntropySource()); 
    5857 
    59             ManagerLibrary.Instance.FileSystemRegistrar.Add(new Fat12FileSystem()); 
    60             ManagerLibrary.Instance.FileSystemRegistrar.Add(new Fat16FileSystem()); 
    61             ManagerLibrary.Instance.FileSystemRegistrar.Add(new Fat32FileSystem()); 
    62             ManagerLibrary.Instance.FileSystemRegistrar.Add(new NtfsFileSystem()); 
     58            Host.Instance.FileSystems.Add(new Fat12FileSystem()); 
     59            Host.Instance.FileSystems.Add(new Fat16FileSystem()); 
     60            Host.Instance.FileSystems.Add(new Fat32FileSystem()); 
     61            Host.Instance.FileSystems.Add(new NtfsFileSystem()); 
    6362 
    64             ManagerLibrary.Instance.ErasureTargetRegistrar.Add(new FileErasureTarget()); 
    65             ManagerLibrary.Instance.ErasureTargetRegistrar.Add(new FolderErasureTarget()); 
    66             ManagerLibrary.Instance.ErasureTargetRegistrar.Add(new RecycleBinErasureTarget()); 
    67             ManagerLibrary.Instance.ErasureTargetRegistrar.Add(new UnusedSpaceErasureTarget()); 
    68             ManagerLibrary.Instance.ErasureTargetRegistrar.Add(new SecureMoveErasureTarget()); 
    69             ManagerLibrary.Instance.ErasureTargetRegistrar.Add(new DriveErasureTarget()); 
     63            Host.Instance.ErasureTargetFactories.Add(new FileErasureTarget()); 
     64            Host.Instance.ErasureTargetFactories.Add(new FolderErasureTarget()); 
     65            Host.Instance.ErasureTargetFactories.Add(new RecycleBinErasureTarget()); 
     66            Host.Instance.ErasureTargetFactories.Add(new UnusedSpaceErasureTarget()); 
     67            Host.Instance.ErasureTargetFactories.Add(new SecureMoveErasureTarget()); 
     68            Host.Instance.ErasureTargetFactories.Add(new DriveErasureTarget()); 
    7069        } 
    7170 
     
    107106    internal class DefaultPluginSettings 
    108107    { 
    109         public DefaultPluginSettings() 
     108        public DefaultPluginSettings(PersistentStore store) 
    110109        { 
    111             settings = Manager.ManagerLibrary.Instance.SettingsManager.ModuleSettings; 
     110            Store = store; 
    112111        } 
    113112 
     
    119118            get 
    120119            { 
    121                 return settings.GetValue<Guid>("FL16Method"); 
     120                return Store.GetValue<Guid>("FL16Method"); 
    122121            } 
    123122            set 
    124123            { 
    125                 settings.SetValue("FL16Method", value); 
     124                Store.SetValue("FL16Method", value); 
    126125            } 
    127126        } 
     
    134133            get 
    135134            { 
    136                 return settings.GetValue<Dictionary<Guid, CustomErasureMethod>>("EraseCustom"); 
     135                return Store.GetValue<Dictionary<Guid, CustomErasureMethod>>("EraseCustom"); 
    137136            } 
    138137            set 
    139138            { 
    140                 settings.SetValue("EraseCustom", value); 
     139                Store.SetValue("EraseCustom", value); 
    141140            } 
    142141        } 
     
    145144        /// The data store for our settings. 
    146145        /// </summary> 
    147         Settings settings; 
     146        PersistentStore Store; 
    148147    } 
    149148} 
  • trunk/eraser/Eraser.DefaultPlugins/Properties/AssemblyInfo.cs

    r1981 r2509  
    2626 
    2727// The plugin is a Core Eraser plugin, declare it so. 
    28 [assembly: Eraser.Manager.Plugin.LoadingPolicy(Eraser.Manager.Plugin.LoadingPolicy.Core)] 
     28[assembly: Eraser.Plugins.PluginLoadingPolicy(Eraser.Plugins.PluginLoadingPolicy.Core)] 
  • trunk/eraser/Eraser.DefaultPlugins/SettingsForm.cs

    r1802 r2509  
    2929using System.Globalization; 
    3030 
    31 using Eraser.Manager; 
    3231using Eraser.Util; 
     32using Eraser.Plugins; 
     33using Eraser.Plugins.ExtensionPoints; 
    3334 
    3435namespace Eraser.DefaultPlugins 
     
    4243 
    4344            //Populate the list of erasure passes, except the FL16KB. 
    44             foreach (ErasureMethod method in ManagerLibrary.Instance.ErasureMethodRegistrar) 
     45            foreach (IErasureMethod method in Host.Instance.ErasureMethods) 
    4546                if (method.Guid != typeof(FirstLast16KB).GUID) 
    4647                    fl16MethodCmb.Items.Add(method); 
     
    5051            if (settings.FL16Method != Guid.Empty) 
    5152                foreach (object item in fl16MethodCmb.Items) 
    52                     if (((ErasureMethod)item).Guid == settings.FL16Method) 
     53                    if (((IErasureMethod)item).Guid == settings.FL16Method) 
    5354                    { 
    5455                        fl16MethodCmb.SelectedItem = item; 
     
    5960            { 
    6061                Guid methodGuid = 
    61                     ManagerLibrary.Settings.DefaultFileErasureMethod; 
     62                    Host.Instance.Settings.DefaultFileErasureMethod; 
    6263                if (methodGuid == typeof(FirstLast16KB).GUID) 
    6364                    methodGuid = typeof(Gutmann).GUID; 
    6465                 
    6566                foreach (object item in fl16MethodCmb.Items) 
    66                     if (((ErasureMethod)item).Guid == methodGuid) 
     67                    if (((IErasureMethod)item).Guid == methodGuid) 
    6768                    { 
    6869                        fl16MethodCmb.SelectedItem = item; 
     
    155156            } 
    156157 
    157             DefaultPlugin.Settings.FL16Method = ((ErasureMethod)fl16MethodCmb.SelectedItem).Guid; 
     158            DefaultPlugin.Settings.FL16Method = ((IErasureMethod)fl16MethodCmb.SelectedItem).Guid; 
    158159 
    159160            //Remove the old methods. 
     
    161162            { 
    162163                customMethods.Remove(guid); 
    163                 ManagerLibrary.Instance.ErasureMethodRegistrar.Remove(guid); 
     164                Host.Instance.ErasureMethods.Remove(guid); 
    164165            } 
    165166 
     
    168169            { 
    169170                customMethods.Add(method.Guid, method); 
    170                 ManagerLibrary.Instance.ErasureMethodRegistrar.Add(new EraseCustom(method)); 
     171                Host.Instance.ErasureMethods.Add(new EraseCustom(method)); 
    171172            } 
    172173 
  • trunk/eraser/Eraser.Manager/DirectExecutor.cs

    r2330 r2509  
    3232using Eraser.Util; 
    3333using Eraser.Util.ExtensionMethods; 
     34using Eraser.Plugins; 
     35using Eraser.Plugins.ExtensionPoints; 
    3436 
    3537namespace Eraser.Manager 
     
    107109 
    108110            DateTime executionTime = (schedule.MissedPreviousSchedule && 
    109                 ManagerLibrary.Settings.ExecuteMissedTasksImmediately) ? 
     111                ManagerLibrary.Instance.Settings.ExecuteMissedTasksImmediately) ? 
    110112                    DateTime.Now : schedule.NextRun; 
    111113 
     
    252254                if (task != null) 
    253255                { 
     256                    LogSink sessionLog = new LogSink(); 
     257                    task.Log.Add(sessionLog); 
     258 
    254259                    //Start a new log session to separate this session's events 
    255260                    //from previous ones. 
    256                     LogSink sessionLog = new LogSink(); 
    257                     task.Log.Add(sessionLog); 
    258                     using (new LogSession(sessionLog)) 
     261                    try 
    259262                    { 
    260                         ExecuteTask(task); 
     263                        using (new LogSession(sessionLog)) 
     264                        { 
     265                            //Set the currently executing task. 
     266                            currentTask = task; 
     267 
     268                            //Prevent the system from sleeping. 
     269                            Power.ExecutionState = ExecutionState.Continuous | 
     270                                ExecutionState.SystemRequired; 
     271 
     272                            task.Execute(); 
     273                        } 
     274                    } 
     275                    finally 
     276                    { 
     277                        //Allow the system to sleep again. 
     278                        Power.ExecutionState = ExecutionState.Continuous; 
     279 
     280                        //If the task is a recurring task, reschedule it for the next execution 
     281                        //time since we are done with this one. 
     282                        if (task.Schedule is RecurringSchedule) 
     283                            ScheduleTask(task); 
     284 
     285                        //Remove the actively executing task from our instance variable 
     286                        currentTask = null; 
    261287                    } 
    262288                } 
     
    264290                //Wait for half a minute to check for the next scheduled task. 
    265291                schedulerInterrupt.WaitOne(30000, false); 
    266             } 
    267         } 
    268  
    269         /// <summary> 
    270         /// Executes the given task. 
    271         /// </summary> 
    272         /// <param name="task">The task to execute.</param> 
    273         private void ExecuteTask(Task task) 
    274         { 
    275             //Set the currently executing task. 
    276             currentTask = task; 
    277  
    278             //Prevent the system from sleeping. 
    279             Power.ExecutionState = ExecutionState.Continuous | ExecutionState.SystemRequired; 
    280  
    281             try 
    282             { 
    283                 //Broadcast the task started event. 
    284                 task.Canceled = false; 
    285                 task.OnTaskStarted(); 
    286  
    287                 //Run the task 
    288                 foreach (ErasureTarget target in task.Targets) 
    289                     try 
    290                     { 
    291                         target.Execute(); 
    292                     } 
    293                     catch (FatalException) 
    294                     { 
    295                         throw; 
    296                     } 
    297                     catch (OperationCanceledException) 
    298                     { 
    299                         throw; 
    300                     } 
    301                     catch (SharingViolationException) 
    302                     { 
    303                     } 
    304             } 
    305             catch (FatalException e) 
    306             { 
    307                 Logger.Log(e.Message, LogLevel.Fatal); 
    308             } 
    309             catch (OperationCanceledException e) 
    310             { 
    311                 Logger.Log(e.Message, LogLevel.Fatal); 
    312             } 
    313             catch (SharingViolationException) 
    314             { 
    315             } 
    316             finally 
    317             { 
    318                 //Allow the system to sleep again. 
    319                 Power.ExecutionState = ExecutionState.Continuous; 
    320  
    321                 //If the task is a recurring task, reschedule it since we are done. 
    322                 if (task.Schedule is RecurringSchedule) 
    323                 { 
    324                     ((RecurringSchedule)task.Schedule).Reschedule(DateTime.Now); 
    325                     ScheduleTask(task); 
    326                 } 
    327  
    328                 //And the task finished event. 
    329                 task.OnTaskFinished(); 
    330  
    331                 //If the task is an execute on restart task or run immediately task, it is 
    332                 //only run once and can now be restored to a manually run task 
    333                 if (task.Schedule == Schedule.RunOnRestart || task.Schedule == Schedule.RunNow) 
    334                     task.Schedule = Schedule.RunManually; 
    335  
    336                 //Remove the actively executing task from our instance variable 
    337                 currentTask = null; 
    338292            } 
    339293        } 
  • trunk/eraser/Eraser.Manager/Eraser.Manager.csproj

    r2320 r2509  
    1515    <AssemblyOriginatorKeyFile>..\Strong Name.snk</AssemblyOriginatorKeyFile> 
    1616    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion> 
     17    <IsWebBootstrapper>false</IsWebBootstrapper> 
     18    <TargetFrameworkProfile /> 
    1719    <PublishUrl>publish\</PublishUrl> 
    1820    <Install>true</Install> 
     
    2729    <ApplicationRevision>0</ApplicationRevision> 
    2830    <ApplicationVersion>1.0.0.%2a</ApplicationVersion> 
    29     <IsWebBootstrapper>false</IsWebBootstrapper> 
    3031    <UseApplicationTrust>false</UseApplicationTrust> 
    3132    <BootstrapperEnabled>true</BootstrapperEnabled> 
    32     <TargetFrameworkProfile /> 
    3333  </PropertyGroup> 
    3434  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> 
     
    6969    </Compile> 
    7070    <Compile Include="DirectExecutor.cs" /> 
    71     <Compile Include="EntropySource.cs" /> 
    72     <Compile Include="ErasureTarget.cs" /> 
    73     <Compile Include="Exception.cs" /> 
     71    <Compile Include="EntropyPoller.cs" /> 
     72    <Compile Include="ErasureTargetCollection.cs" /> 
    7473    <Compile Include="Executor.cs" /> 
    75     <Compile Include="FileSystem.cs" /> 
    76     <Compile Include="IConfigurer.cs" /> 
    77     <Compile Include="IRegistrar.cs" /> 
    7874    <Compile Include="ManagerLibrary.cs" /> 
    79     <Compile Include="ErasureMethod.cs" /> 
    80     <Compile Include="Plugins.cs" /> 
    81     <Compile Include="PRNG.cs" /> 
    8275    <Compile Include="Properties\AssemblyInfo.cs" /> 
    8376    <Compile Include="RemoteExecutor.cs" /> 
     
    8780  </ItemGroup> 
    8881  <ItemGroup> 
     82    <ProjectReference Include="..\Eraser.Plugins\Eraser.Plugins.csproj"> 
     83      <Project>{59F7ED0F-3589-4112-B612-4A9A6588F4A0}</Project> 
     84      <Name>Eraser.Plugins</Name> 
     85    </ProjectReference> 
    8986    <ProjectReference Include="..\Eraser.Util.Native\Eraser.Util.Native.vcxproj"> 
    9087      <Project>{BCFE7D20-FC82-4BBE-BFE4-7B635D70D238}</Project> 
  • trunk/eraser/Eraser.Manager/ManagerLibrary.cs

    r2049 r2509  
    2525using System.Runtime.Serialization; 
    2626 
     27using Eraser.Plugins; 
     28using Eraser.Util; 
     29 
    2730namespace Eraser.Manager 
    2831{ 
     
    3336    public class ManagerLibrary : IDisposable 
    3437    { 
    35         public ManagerLibrary(SettingsManager settings) 
     38        public ManagerLibrary(PersistentStore persistentStore) 
    3639        { 
    3740            if (Instance != null) 
     
    4043 
    4144            Instance = this; 
    42             SettingsManager = settings; 
    43  
    44             EntropySourceRegistrar = new EntropySourceRegistrar(); 
    45             PrngRegistrar = new PrngRegistrar(); 
    46             ErasureMethodRegistrar = new ErasureMethodRegistrar(); 
    47             ErasureTargetRegistrar = new ErasureTargetRegistrar(); 
    48             FileSystemRegistrar = new FileSystemRegistrar(); 
    49             Host = new Plugin.DefaultHost(); 
    50             Host.Load(); 
     45            Settings = new ManagerSettings(persistentStore); 
     46            entropyPoller = new EntropyPoller(); 
     47            Host.Initialise(persistentStore); 
     48            Host.Instance.PluginLoad += OnPluginLoad; 
     49            Host.Instance.Load(); 
    5150        } 
    5251 
     
    5857        protected virtual void Dispose(bool disposing) 
    5958        { 
    60             if (SettingsManager == null) 
     59            if (Settings == null) 
    6160                return; 
    6261 
    6362            if (disposing) 
    6463            { 
    65                 EntropySourceRegistrar.Poller.Abort(); 
    66                 Host.Dispose(); 
    67                 SettingsManager.Save(); 
     64                entropyPoller.Abort(); 
     65                Host.Instance.Dispose(); 
    6866            } 
    6967 
    70             SettingsManager = null; 
     68            Settings = null; 
    7169            Instance = null; 
    7270        } 
     
    7876        } 
    7977 
     78        private void OnPluginLoad(object sender, PluginLoadEventArgs e) 
     79        { 
     80            //If the plugin does not have an approval or denial, check for the presence of 
     81            //a valid signature. 
     82            IDictionary<Guid, bool> approvals = Settings.PluginApprovals; 
     83            if (!approvals.ContainsKey(e.Plugin.AssemblyInfo.Guid) && 
     84                (e.Plugin.Assembly.GetName().GetPublicKey().Length == 0 || 
     85                !Security.VerifyStrongName(e.Plugin.Assembly.Location) || 
     86                e.Plugin.AssemblyAuthenticode == null)) 
     87            { 
     88                e.Load = false; 
     89            } 
     90 
     91            //Is there an approval or denial? 
     92            else if (approvals.ContainsKey(e.Plugin.AssemblyInfo.Guid)) 
     93                e.Load = approvals[e.Plugin.AssemblyInfo.Guid]; 
     94 
     95            //There's no approval or denial, what is the specified loading policy? 
     96            else 
     97                e.Load = e.Plugin.LoadingPolicy != PluginLoadingPolicy.DefaultOff; 
     98        } 
     99 
    80100        /// <summary> 
    81101        /// The global library instance. 
     
    84104 
    85105        /// <summary> 
    86         /// The global instance of the EntropySource Manager 
     106        /// Gets the settings object representing the settings for the Eraser Manager. 
    87107        /// </summary> 
    88         public EntropySourceRegistrar EntropySourceRegistrar { get; private set; } 
    89  
    90         /// <summary> 
    91         /// The global instance of the PRNG Manager. 
    92         /// </summary> 
    93         public PrngRegistrar PrngRegistrar { get; private set; } 
    94  
    95         /// <summary> 
    96         /// The global instance of the Erasure method Manager. 
    97         /// </summary> 
    98         public ErasureMethodRegistrar ErasureMethodRegistrar { get; private set; } 
    99  
    100         /// <summary> 
    101         /// The global instance of the Erasure target Manager. 
    102         /// </summary> 
    103         public ErasureTargetRegistrar ErasureTargetRegistrar { get; private set; } 
    104  
    105         /// <summary> 
    106         /// The global instance of the File System manager. 
    107         /// </summary> 
    108         public FileSystemRegistrar FileSystemRegistrar { get; private set; } 
    109  
    110         /// <summary> 
    111         /// Global instance of the Settings manager. 
    112         /// </summary> 
    113         public SettingsManager SettingsManager { get; set; } 
    114  
    115         /// <summary> 
    116         /// Gets the settings object representing the settings for the Eraser 
    117         /// Manager. This is just shorthand for the local classes. 
    118         /// </summary> 
    119         public static ManagerSettings Settings 
     108        public ManagerSettings Settings 
    120109        { 
    121             get 
    122             { 
    123                 if (settingsInstance == null) 
    124                     settingsInstance = new ManagerSettings(); 
    125                 return settingsInstance; 
    126             } 
     110            get; 
     111            private set; 
    127112        } 
    128113 
    129114        /// <summary> 
    130         /// The singleton instance for <see cref="Settings"/>. 
     115        /// The entropy poller thread which will gather entropy and push it to 
     116        /// the PRNGs. 
    131117        /// </summary> 
    132         private static ManagerSettings settingsInstance; 
    133  
    134         /// <summary> 
    135         /// The global instance of the Plugin host. 
    136         /// </summary> 
    137         internal Plugin.DefaultHost Host; 
     118        private EntropyPoller entropyPoller; 
    138119    } 
    139120} 
  • trunk/eraser/Eraser.Manager/Settings.cs

    r2013 r2509  
    2525using System.Reflection; 
    2626using System.Runtime.InteropServices; 
     27using System.Globalization; 
     28 
    2729using Eraser.Util; 
    28 using System.Globalization; 
     30using Eraser.Plugins; 
     31using Eraser.Plugins.ExtensionPoints; 
    2932 
    3033namespace Eraser.Manager 
    3134{ 
    32     public abstract class SettingsManager 
    33     { 
    34         /// <summary> 
    35         /// Saves all the settings to persistent storage. 
    36         /// </summary> 
    37         public abstract void Save(); 
    38  
    39         /// <summary> 
    40         /// Gets the dictionary holding settings for the calling assembly. 
    41         /// </summary> 
    42         public Settings ModuleSettings 
    43         { 
    44             get 
    45             { 
    46                 return GetSettings(new Guid(((GuidAttribute)Assembly.GetCallingAssembly(). 
    47                     GetCustomAttributes(typeof(GuidAttribute), false)[0]).Value)); 
    48             } 
    49         } 
    50  
    51         /// <summary> 
    52         /// Gets the settings from the data source. 
    53         /// </summary> 
    54         /// <param name="value">The GUID of the calling plugin</param> 
    55         /// <returns>The Settings object which will act as the data store.</returns> 
    56         protected abstract Settings GetSettings(Guid value); 
    57     } 
    58  
    59     /// <summary> 
    60     /// Settings class. Represents settings to a given client. 
    61     /// </summary> 
    62     public abstract class Settings 
    63     { 
    64         /// <summary> 
    65         /// Gets the setting for the given name, coercing the object stored in the backend 
    66         /// to the given type <typeparamref name="T"/>. 
    67         /// </summary> 
    68         /// <typeparam name="T">The type of the setting that is currently stored in the 
    69         /// backend.</typeparam> 
    70         /// <param name="name">The name of the setting that is used to uniquely refer 
    71         /// to the value.</param> 
    72         /// <param name="defaultValue">The default to return if the no data is assocated 
    73         /// with the given setting.</param> 
    74         /// <returns>The value stored in the backend, or null if none exists.</returns> 
    75         public abstract T GetValue<T>(string name, T defaultValue); 
    76  
    77         /// <summary> 
    78         /// Overload for <see cref="GetValue"/> which returns a default for the given type. 
    79         /// </summary> 
    80         /// <typeparam name="T">The type of the setting that is currently stored in the 
    81         /// backend.</typeparam> 
    82         /// <param name="name">The name of the setting that is used to uniquely refer 
    83         /// to the value.</param> 
    84         /// <param name="defaultValue">The default to return if the no data is assocated 
    85         /// with the given setting.</param> 
    86         /// <returns>The value stored in the backend, or null if none exists.</returns> 
    87         public T GetValue<T>(string name) 
    88         { 
    89             return GetValue<T>(name, default(T)); 
    90         } 
    91  
    92         /// <summary> 
    93         /// Sets the setting with the given name. 
    94         /// </summary> 
    95         /// <param name="name">The name of the setting.</param> 
    96         /// <param name="value">The value to store in the backend. This may be serialised.</param> 
    97         public abstract void SetValue(string name, object value); 
    98  
    99         /// <summary> 
    100         /// Gets or sets the given setting, without type hinting. This will not attempt to coerce 
    101         /// a type from an old version of the assembly to its current type. 
    102         /// </summary> 
    103         /// <param name="setting">The name of the setting.</param> 
    104         /// <returns>The object stored in the settings database, or null if undefined.</returns> 
    105         [Obsolete("Use the GetValue<T> and SetValue functions instead")] 
    106         public object this[string setting] 
    107         { 
    108             get 
    109             { 
    110                 return GetValue<object>(setting); 
    111             } 
    112             set 
    113             { 
    114                 SetValue(setting, value); 
    115             } 
    116         } 
    117     } 
    118  
    119     #region Default attributes 
    120     /// <summary> 
    121     /// Indicates that the marked class should be used as a default when no 
    122     /// settings have been set by the user. 
    123     /// </summary> 
    124     [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)] 
    125     public abstract class DefaultAttribute : Attribute 
    126     { 
    127         /// <summary> 
    128         /// Constructor. 
    129         /// </summary> 
    130         /// <param name="priority">The priority of the current element in terms of 
    131         /// it being the default.</param> 
    132         protected DefaultAttribute(int priority) 
    133         { 
    134             Priority = priority; 
    135         } 
    136  
    137         /// <summary> 
    138         /// The priority of the default. 
    139         /// </summary> 
    140         public int Priority 
    141         { 
    142             get 
    143             { 
    144                 return priority; 
    145             } 
    146             private set 
    147             { 
    148                 priority = value; 
    149             } 
    150         } 
    151  
    152         private int priority; 
    153     } 
    154  
    155     /// <summary> 
    156     /// Indicates that the marked class should be used as the default file erasure 
    157     /// method. 
    158     /// </summary> 
    159     [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)] 
    160     public sealed class DefaultFileErasureAttribute : DefaultAttribute 
    161     { 
    162         /// <summary> 
    163         /// Constructor. 
    164         /// </summary> 
    165         /// <param name="priority">The priority of the current element in terms of 
    166         /// it being the default.</param> 
    167         public DefaultFileErasureAttribute(int priority) 
    168             : base(priority) 
    169         { 
    170         } 
    171     } 
    172  
    173     /// <summary> 
    174     /// Indicates that the marked class should be used as the default unused space 
    175     /// erasure method. 
    176     /// </summary> 
    177     [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)] 
    178     public sealed class DefaultUnusedSpaceErasureAttribute : DefaultAttribute 
    179     { 
    180         /// <summary> 
    181         /// Constructor. 
    182         /// </summary> 
    183         /// <param name="priority">The priority of the current element in terms of 
    184         /// it being the default.</param> 
    185         public DefaultUnusedSpaceErasureAttribute(int priority) 
    186             : base(priority) 
    187         { 
    188         } 
    189     } 
    190  
    191     /// <summary> 
    192     /// Indicates that the marked class should be used as the default PRNG. 
    193     /// </summary> 
    194     [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)] 
    195     public sealed class DefaultPrngAttribute : DefaultAttribute 
    196     { 
    197         /// <summary> 
    198         /// Constructor. 
    199         /// </summary> 
    200         /// <param name="priority">The priority of the current element in terms of 
    201         /// it being the default.</param> 
    202         public DefaultPrngAttribute(int priority) 
    203             : base(priority) 
    204         { 
    205         } 
    206     } 
    207     #endregion 
    208  
    20935    /// <summary> 
    21036    /// Presents an opaque type for the management of the Manager settings. 
     
    21541        /// Constructor. 
    21642        /// </summary> 
    217         /// <param name="settings">The Settings object which is the data store for 
    218         /// this object.</param> 
    219         public ManagerSettings() 
     43        /// <param name="settings">The Persistent Store for this object.</param> 
     44        public ManagerSettings(PersistentStore store) 
    22045        { 
    221             settings = ManagerLibrary.Instance.SettingsManager.ModuleSettings; 
    222         } 
    223  
    224         /// <summary> 
    225         /// The default file erasure method. This is a GUID since methods are 
    226         /// implemented through plugins and plugins may not be loaded and missing 
    227         /// references may follow. 
    228         /// </summary> 
    229         public Guid DefaultFileErasureMethod 
    230         { 
    231             get 
    232             { 
    233                 //If the user did not define anything for this field, check all plugins 
    234                 //and use the method which was declared by us to be the highest 
    235                 //priority default 
    236                 Guid result = settings.GetValue<Guid>("DefaultFileErasureMethod"); 
    237                 if (result == Guid.Empty) 
    238                     result = FindHighestPriorityDefault(typeof(ErasureMethod), 
    239                         typeof(DefaultFileErasureAttribute)); 
    240                 if (result == Guid.Empty) 
    241                     result = new Guid("{1407FC4E-FEFF-4375-B4FB-D7EFBB7E9922}"); 
    242  
    243                 return result; 
    244             } 
    245             set 
    246             { 
    247                 settings.SetValue("DefaultFileErasureMethod", value); 
    248             } 
    249         } 
    250  
    251         /// <summary> 
    252         /// The default unused space erasure method. This is a GUID since methods 
    253         /// are implemented through plugins and plugins may not be loaded and 
    254         /// missing references may follow. 
    255         /// </summary> 
    256         public Guid DefaultUnusedSpaceErasureMethod 
    257         { 
    258             get 
    259             { 
    260                 Guid result = settings.GetValue<Guid>("DefaultUnusedSpaceErasureMethod"); 
    261                 if (result == Guid.Empty) 
    262                     result = FindHighestPriorityDefault(typeof(UnusedSpaceErasureMethod), 
    263                         typeof(DefaultUnusedSpaceErasureAttribute)); 
    264                 if (result == Guid.Empty) 
    265                     result = new Guid("{BF8BA267-231A-4085-9BF9-204DE65A6641}"); 
    266                 return result; 
    267             } 
    268             set 
    269             { 
    270                 settings.SetValue("DefaultUnusedSpaceErasureMethod", value); 
    271             } 
    272         } 
    273  
    274         /// <summary> 
    275         /// The PRNG used. This is a GUID since PRNGs are implemented through 
    276         /// plugins and plugins may not be loaded and missing references may follow. 
    277         /// </summary> 
    278         public Guid ActivePrng 
    279         { 
    280             get 
    281             { 
    282                 Guid result = settings.GetValue<Guid>("ActivePRNG"); 
    283                 if (result == Guid.Empty) 
    284                     result = FindHighestPriorityDefault(typeof(Prng), typeof(DefaultPrngAttribute)); 
    285                 if (result == Guid.Empty) 
    286                     result = new Guid("{6BF35B8E-F37F-476e-B6B2-9994A92C3B0C}"); 
    287                 return result; 
    288             } 
    289             set 
    290             { 
    291                 settings.SetValue("ActivePRNG", value); 
    292             } 
    293         } 
    294  
    295         /// <summary> 
    296         /// Whether files which are locked when being erased should be forcibly 
    297         /// unlocked for erasure. 
    298         /// </summary> 
    299         public bool ForceUnlockLockedFiles 
    300         { 
    301             get 
    302             { 
    303                 return settings.GetValue("ForceUnlockLockedFiles", true); 
    304             } 
    305             set 
    306             { 
    307                 settings.SetValue("ForceUnlockLockedFiles", value); 
    308             } 
     46            Store = store; 
    30947        } 
    31048 
     
    31654            get 
    31755            { 
    318                 return settings.GetValue("ExecuteMissedTasksImmediately", true); 
     56                return Store.GetValue("ExecuteMissedTasksImmediately", true); 
    31957            } 
    32058            set 
    32159            { 
    322                 settings.SetValue("ExecuteMissedTasksImmediately", value); 
     60                Store.SetValue("ExecuteMissedTasksImmediately", value); 
    32361            } 
    32462        } 
    325  
    326         /// <summary> 
    327         /// Whether erasures should be run with plausible deniability. This is 
    328         /// achieved by the executor copying files over the file to be removed 
    329         /// before removing it. 
    330         /// </summary> 
    331         /// <seealso cref="PlausibleDeniabilityFiles"/> 
    332         public bool PlausibleDeniability 
    333         { 
    334             get 
    335             { 
    336                 return settings.GetValue("PlausibleDeniability", false); 
    337             } 
    338             set 
    339             { 
    340                 settings.SetValue("PlausibleDeniability", value); 
    341             } 
    342         } 
    343  
    344         /// <summary> 
    345         /// The files which are overwritten with when a file has been erased. 
    346         /// </summary> 
    347         public IList<string> PlausibleDeniabilityFiles 
    348         { 
    349             get 
    350             { 
    351                 return new SettingsList<string>(settings, "PlausibleDeniabilityFiles"); 
    352             } 
    353         } 
    354  
    355         #region Default Attributes retrieval 
    356         /// <summary> 
    357         /// Finds the type for the given attribute that is the default (i.e. the 
    358         /// DefaultAttribute value is the highest) and that the type inherits 
    359         /// from the given <paramref name="superClass"/>. 
    360         /// </summary> 
    361         /// <param name="superClass">A class that the default must inherit from.</param> 
    362         /// <param name="attributeType">The attribute to look for.</param> 
    363         /// <returns>The GUID of the type that is the default.</returns> 
    364         private static Guid FindHighestPriorityDefault(Type superClass, 
    365             Type attributeType) 
    366         { 
    367             //Check if we've computed the value before. If so, we return the cached 
    368             //value. 
    369             if (DefaultForAttributes.ContainsKey(attributeType) && 
    370                 DefaultForAttributes[attributeType].ContainsKey(superClass)) 
    371             { 
    372                 return DefaultForAttributes[attributeType][superClass]; 
    373             } 
    374  
    375             //We have not computed the value. Compute the default. 
    376             Plugin.Host pluginHost = ManagerLibrary.Instance.Host; 
    377             IList<Plugin.PluginInstance> plugins = pluginHost.Plugins; 
    378             SortedList<int, Guid> priorities = new SortedList<int, Guid>(); 
    379  
    380             foreach (Plugin.PluginInstance plugin in plugins) 
    381             { 
    382                 //Check whether the plugin is signed by us. 
    383                 byte[] pluginKey = plugin.Assembly.GetName().GetPublicKey(); 
    384                 byte[] ourKey = Assembly.GetExecutingAssembly().GetName().GetPublicKey(); 
    385  
    386                 if (pluginKey.Length != ourKey.Length || 
    387                     !Security.VerifyStrongName(plugin.Assembly.Location)) 
    388                     continue; 
    389                 bool officialPlugin = true; 
    390                 for (int i = 0, j = ourKey.Length; i != j; ++i) 
    391                     if (pluginKey[i] != ourKey[i]) 
    392                         officialPlugin = false; 
    393                 if (!officialPlugin) 
    394                     continue; 
    395  
    396                 Type[] types = FindTypeAttributeInAssembly(plugin.Assembly, 
    397                     superClass, attributeType); 
    398  
    399                 //Prioritize the types. 
    400                 if (types != null) 
    401                     foreach (Type type in types) 
    402                     { 
    403                         object[] guids = 
    404                             type.GetCustomAttributes(typeof(GuidAttribute), false); 
    405                         DefaultAttribute defaultAttr = (DefaultAttribute) 
    406                             type.GetCustomAttributes(attributeType, false)[0]; 
    407  
    408                         if (guids.Length == 1) 
    409                             priorities.Add(defaultAttr.Priority, 
    410                                 new Guid(((GuidAttribute)guids[0]).Value)); 
    411                     } 
    412             } 
    413  
    414             //If we actually have a result, cache it then return the result. 
    415             if (priorities.Count > 0) 
    416             { 
    417                 Guid result = priorities[priorities.Keys[priorities.Count - 1]]; 
    418                 if (!DefaultForAttributes.ContainsKey(attributeType)) 
    419                     DefaultForAttributes.Add(attributeType, new Dictionary<Type, Guid>()); 
    420                 DefaultForAttributes[attributeType].Add(superClass, result); 
    421                 return result; 
    422             } 
    423  
    424             //If we do not have any results, don't store it. 
    425             return Guid.Empty; 
    426         } 
    427  
    428         /// <summary> 
    429         /// Finds a type with the given characteristics in the provided assembly. 
    430         /// </summary> 
    431         /// <param name="assembly">The assembly to look into.</param> 
    432         /// <param name="superClass">A class the type must inherit from.</param> 
    433         /// <param name="attributeType">The attribute the class must possess.</param> 
    434         /// <returns>An array of types with the given characteristics.</returns> 
    435         private static Type[] FindTypeAttributeInAssembly(Assembly assembly, Type superClass, 
    436             Type attributeType) 
    437         { 
    438             //Yes, if we got here the plugin is signed by us. Find the 
    439             //type which inherits from ErasureMethod. 
    440             Type[] types = assembly.GetExportedTypes(); 
    441             List<Type> result = new List<Type>(); 
    442             foreach (Type type in types) 
    443             { 
    444                 if (!type.IsPublic || type.IsAbstract) 
    445                     //Not interesting. 
    446                     continue; 
    447  
    448                 //Try to see if this class inherits from the specified super class. 
    449                 if (!type.IsSubclassOf(superClass)) 
    450                     continue; 
    451  
    452                 //See if this class has the DefaultFileErasureAttribute 
    453                 object[] attributes = type.GetCustomAttributes(attributeType, false); 
    454                 if (attributes.Length > 0) 
    455                     result.Add(type); 
    456             } 
    457  
    458             return result.ToArray(); 
    459         } 
    460  
    461         /// <summary> 
    462         /// Caches the defaults as computed by FindHighestPriorityDefault. The first 
    463         /// key is the attribute type, the second key is the superclass, the 
    464         /// value is the Guid. 
    465         /// </summary> 
    466         private static Dictionary<Type, Dictionary<Type, Guid>> DefaultForAttributes = 
    467             new Dictionary<Type, Dictionary<Type, Guid>>(); 
    468         #endregion 
    46963 
    47064        /// <summary> 
     
    47670            get 
    47771            { 
    478                 return new SettingsDictionary<Guid, bool>(settings, "ApprovedPlugins"); 
     72                return Store.GetValue<IDictionary<Guid, bool>>("ApprovedPlugins"); 
    47973            } 
    48074        } 
    48175 
    48276        /// <summary> 
    483         /// The Settings object which is the data store of this object. 
     77        /// The Persistent Store behind all these settings. 
    48478        /// </summary> 
    485         private Settings settings; 
    486  
    487         /// <summary> 
    488         /// Encapsulates an abstract list that is used to store settings. 
    489         /// </summary> 
    490         /// <typeparam name="T">The type of the list element.</typeparam> 
    491         private class SettingsList<T> : IList<T> 
    492         { 
    493             public SettingsList(Settings settings, string settingName) 
    494             { 
    495                 Settings = settings; 
    496                 SettingName = settingName; 
    497                 List = new List<T>(); 
    498  
    499                 T[] values = settings.GetValue<T[]>(settingName); 
    500                 if (values != null) 
    501                     List.AddRange(values); 
    502             } 
    503  
    504             ~SettingsList() 
    505             { 
    506                 Save(); 
    507             } 
    508  
    509             #region IList<T> Members 
    510  
    511             public int IndexOf(T item) 
    512             { 
    513                 return List.IndexOf(item); 
    514             } 
    515  
    516             public void Insert(int index, T item) 
    517             { 
    518                 List.Insert(index, item); 
    519                 Save(); 
    520             } 
    521  
    522             public void RemoveAt(int index) 
    523             { 
    524                 List.RemoveAt(index); 
    525                 Save(); 
    526             } 
    527  
    528             public T this[int index] 
    529             { 
    530                 get 
    531                 { 
    532                     return List[index]; 
    533                 } 
    534                 set 
    535                 { 
    536                     List[index] = value; 
    537                     Save(); 
    538                 } 
    539             } 
    540  
    541             #endregion 
    542  
    543             #region ICollection<T> Members 
    544  
    545             public void Add(T item) 
    546             { 
    547                 List.Add(item); 
    548                 Save(); 
    549             } 
    550  
    551             public void Clear() 
    552             { 
    553                 List.Clear(); 
    554                 Save(); 
    555             } 
    556  
    557             public bool Contains(T item) 
    558             { 
    559                 return List.Contains(item); 
    560             } 
    561  
    562             public void CopyTo(T[] array, int arrayIndex) 
    563             { 
    564                 List.CopyTo(array, arrayIndex); 
    565             } 
    566  
    567             public int Count 
    568             { 
    569                 get { return List.Count; } 
    570             } 
    571  
    572             public bool IsReadOnly 
    573             { 
    574                 get { return false; } 
    575             } 
    576  
    577             public bool Remove(T item) 
    578             { 
    579                 bool result = List.Remove(item); 
    580                 Save(); 
    581                 return result; 
    582             } 
    583  
    584             #endregion 
    585  
    586             #region IEnumerable<T> Members 
    587  
    588             public IEnumerator<T> GetEnumerator() 
    589             { 
    590                 return List.GetEnumerator(); 
    591             } 
    592  
    593             #endregion 
    594  
    595             #region IEnumerable Members 
    596  
    597             System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    598             { 
    599                 return List.GetEnumerator(); 
    600             } 
    601  
    602             #endregion 
    603  
    604             /// <summary> 
    605             /// Saves changes made to the list to the settings manager. 
    606             /// </summary> 
    607             private void Save() 
    608             { 
    609                 Settings.SetValue(SettingName, List); 
    610             } 
    611  
    612             /// <summary> 
    613             /// The settings object storing the settings. 
    614             /// </summary> 
    615             private Settings Settings; 
    616  
    617             /// <summary> 
    618             /// The name of the setting we are encapsulating. 
    619             /// </summary> 
    620             private string SettingName; 
    621  
    622             /// <summary> 
    623             /// The list we are using as scratch. 
    624             /// </summary> 
    625             private List<T> List; 
    626         } 
    627  
    628         /// <summary> 
    629         /// Encapsulates an abstract dictionary that is used to store settings. 
    630         /// </summary> 
    631         /// <typeparam name="TKey">The key type of the dictionary.</typeparam> 
    632         /// <typeparam name="TValue">The value type of the dictionary.</typeparam> 
    633         private class SettingsDictionary<TKey, TValue> : IDictionary<TKey, TValue> 
    634         { 
    635             public SettingsDictionary(Settings settings, string settingName) 
    636             { 
    637                 Settings = settings; 
    638                 SettingName = settingName; 
    639                 Dictionary = settings.GetValue<Dictionary<TKey, TValue>>(settingName); 
    640                 if (Dictionary == null) 
    641                     Dictionary = new Dictionary<TKey, TValue>(); 
    642             } 
    643  
    644             ~SettingsDictionary() 
    645             { 
    646                 Save(); 
    647             } 
    648  
    649             #region IDictionary<TKey,TValue> Members 
    650  
    651             public void Add(TKey key, TValue value) 
    652             { 
    653                 Dictionary.Add(key, value); 
    654                 Save(); 
    655             } 
    656  
    657             public bool ContainsKey(TKey key) 
    658             { 
    659                 return Dictionary.ContainsKey(key); 
    660             } 
    661  
    662             public ICollection<TKey> Keys 
    663             { 
    664                 get { return Dictionary.Keys; } 
    665             } 
    666  
    667             public bool Remove(TKey key) 
    668             { 
    669                 bool result = Dictionary.Remove(key); 
    670                 Save(); 
    671                 return result; 
    672             } 
    673  
    674             public bool TryGetValue(TKey key, out TValue value) 
    675             { 
    676                 return Dictionary.TryGetValue(key, out value); 
    677             } 
    678  
    679             public ICollection<TValue> Values 
    680             { 
    681                 get { return Dictionary.Values; } 
    682             } 
    683  
    684             public TValue this[TKey key] 
    685             { 
    686                 get 
    687                 { 
    688                     return Dictionary[key]; 
    689                 } 
    690                 set 
    691                 { 
    692                     Dictionary[key] = value; 
    693                     Save(); 
    694                 } 
    695             } 
    696  
    697             #endregion 
    698  
    699             #region ICollection<KeyValuePair<TKey,TValue>> Members 
    700  
    701             public void Add(KeyValuePair<TKey, TValue> item) 
    702             { 
    703                 Dictionary.Add(item.Key, item.Value); 
    704                 Save(); 
    705             } 
    706  
    707             public void Clear() 
    708             { 
    709                 Dictionary.Clear(); 
    710                 Save(); 
    711             } 
    712  
    713             public bool Contains(KeyValuePair<TKey, TValue> item) 
    714             { 
    715                 return Dictionary.ContainsKey(item.Key) && Dictionary[item.Key].Equals(item.Value); 
    716             } 
    717  
    718             public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) 
    719             { 
    720                 throw new NotImplementedException(); 
    721             } 
    722  
    723             public int Count 
    724             { 
    725                 get { return Dictionary.Count; } 
    726             } 
    727  
    728             public bool IsReadOnly 
    729             { 
    730                 get { return false; } 
    731             } 
    732  
    733             public bool Remove(KeyValuePair<TKey, TValue> item) 
    734             { 
    735                 if (Dictionary.ContainsKey(item.Key) && Dictionary[item.Key].Equals(item.Value)) 
    736                 { 
    737                     bool result = Dictionary.Remove(item.Key); 
    738                     Save(); 
    739                     return result; 
    740                 } 
    741  
    742                 return false; 
    743             } 
    744  
    745             #endregion 
    746  
    747             #region IEnumerable<KeyValuePair<TKey,TValue>> Members 
    748  
    749             public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() 
    750             { 
    751                 return Dictionary.GetEnumerator(); 
    752             } 
    753  
    754             #endregion 
    755  
    756             #region IEnumerable Members 
    757  
    758             System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    759             { 
    760                 return Dictionary.GetEnumerator(); 
    761             } 
    762  
    763             #endregion 
    764  
    765             /// <summary> 
    766             /// Saves changes made to the list to the settings manager. 
    767             /// </summary> 
    768             private void Save() 
    769             { 
    770                 Settings.SetValue(SettingName, Dictionary); 
    771             } 
    772  
    773             /// <summary> 
    774             /// The settings object storing the settings. 
    775             /// </summary> 
    776             private Settings Settings; 
    777  
    778             /// <summary> 
    779             /// The name of the setting we are encapsulating. 
    780             /// </summary> 
    781             private string SettingName; 
    782  
    783             /// <summary> 
    784             /// The list we are using as scratch. 
    785             /// </summary> 
    786             private Dictionary<TKey, TValue> Dictionary; 
    787         } 
    788  
     79        private PersistentStore Store; 
    78980    } 
    79081} 
  • trunk/eraser/Eraser.Manager/Task.cs

    r2275 r2509  
    3030using Eraser.Util; 
    3131using Eraser.Util.ExtensionMethods; 
     32using Eraser.Plugins; 
     33using Eraser.Plugins.ExtensionPoints; 
    3234 
    3335namespace Eraser.Manager 
     
    3739    /// </summary> 
    3840    [Serializable] 
    39     public class Task : ISerializable 
     41    public class Task : ITask, ISerializable 
    4042    { 
    4143        #region Serialization code 
     
    4446            Name = (string)info.GetValue("Name", typeof(string)); 
    4547            Executor = context.Context as Executor; 
    46             Targets = (ErasureTargetsCollection)info.GetValue("Targets", typeof(ErasureTargetsCollection)); 
     48            Targets = (ErasureTargetCollection)info.GetValue("Targets", typeof(ErasureTargetCollection)); 
    4749            Targets.Owner = this; 
    4850            Log = (List<LogSink>)info.GetValue("Log", typeof(List<LogSink>)); 
     
    7981        { 
    8082            Name = string.Empty; 
    81             Targets = new ErasureTargetsCollection(this); 
     83            Targets = new ErasureTargetCollection(this); 
    8284            Schedule = Schedule.RunNow; 
    8385            Canceled = false; 
     
    8688 
    8789        /// <summary> 
    88         /// Cancels the task from running, or, if the task is queued for running, 
    89         /// removes the task from the queue. 
    90         /// </summary> 
    91         public void Cancel() 
    92         { 
    93             Executor.UnqueueTask(this); 
    94             Canceled = true; 
    95         } 
    96  
    97         /// <summary> 
    9890        /// The Executor object which is managing this task. 
    9991        /// </summary> 
    100         public Executor Executor { get; internal set; } 
     92        public Executor Executor 
     93        { 
     94            get 
     95            { 
     96                return executor; 
     97            } 
     98            internal set 
     99            { 
     100                if (executor != null && value != null) 
     101                    throw new InvalidOperationException("A task can only belong to one " + 
     102                        "executor at any one time"); 
     103 
     104                executor = value; 
     105            } 
     106        } 
    101107 
    102108        /// <summary> 
     
    109115        /// The name of the task, used for display in UI elements. 
    110116        /// </summary> 
    111         public string UIText 
    112         { 
    113             get 
    114             { 
    115                 //Simple case, the task name was given by the user. 
    116                 if (!string.IsNullOrEmpty(Name)) 
    117                     return Name; 
    118  
    119                 string result = string.Empty; 
    120                 if (Targets.Count == 0) 
    121                     return result; 
    122                 else if (Targets.Count < 5) 
    123                 { 
    124                     //Simpler case, small set of data. 
    125                     foreach (ErasureTarget tgt in Targets) 
    126                         result += S._("{0}, ", tgt.UIText); 
    127  
    128                     return result.Remove(result.Length - 2); 
    129                 } 
    130                 else 
    131                 { 
    132                     //Ok, we've quite a few entries, get the first, the mid and the end. 
    133                     result = S._("{0}, ", Targets[0].UIText); 
    134                     result += S._("{0}, ", Targets[Targets.Count / 2].UIText); 
    135                     result += Targets[Targets.Count - 1].UIText; 
    136  
    137                     return S._("{0} and {1} other targets", result, Targets.Count - 3); 
    138                 } 
    139             } 
    140         } 
    141  
    142         /// <summary> 
    143         /// Gets the status of the task - whether it is being executed. 
    144         /// </summary> 
    145         public bool Executing { get; private set; } 
    146  
    147         /// <summary> 
    148         /// Gets whether this task is currently queued to run. This is true only 
    149         /// if the queue it is in is an explicit request, i.e will run when the 
    150         /// executor is idle. 
    151         /// </summary> 
    152         public bool Queued 
    153         { 
    154             get 
    155             { 
    156                 return Executor.IsTaskQueued(this); 
    157             } 
    158         } 
    159  
    160         /// <summary> 
    161         /// Gets whether the task has been cancelled from execution. 
    162         /// </summary> 
    163         public bool Canceled 
    164         { 
    165             get; 
    166             internal set; 
     117        public override string ToString() 
     118        { 
     119            //Simple case, the task name was given by the user. 
     120            if (!string.IsNullOrEmpty(Name)) 
     121                return Name; 
     122 
     123            string result = string.Empty; 
     124            if (Targets.Count == 0) 
     125                return result; 
     126            else if (Targets.Count < 5) 
     127            { 
     128                //Simpler case, small set of data. 
     129                foreach (IErasureTarget tgt in Targets) 
     130                    result += S._("{0}, ", tgt); 
     131 
     132                return result.Remove(result.Length - 2); 
     133            } 
     134            else 
     135            { 
     136                //Ok, we've quite a few entries, get the first, the mid and the end. 
     137                result = S._("{0}, ", Targets[0]); 
     138                result += S._("{0}, ", Targets[Targets.Count / 2]); 
     139                result += Targets[Targets.Count - 1]; 
     140 
     141                return S._("{0} and {1} other targets", result, Targets.Count - 3); 
     142            } 
    167143        } 
    168144 
     
    170146        /// The set of data to erase when this task is executed. 
    171147        /// </summary> 
    172         public ErasureTargetsCollection Targets { get; private set; } 
     148        public ErasureTargetCollection Targets { get; private set; } 
     149 
     150        /// <summary> 
     151        /// <see cref="Targets"/> 
     152        /// </summary> 
     153        ICollection<IErasureTarget> ITask.Targets 
     154        { 
     155            get { return Targets; } 
     156        } 
    173157 
    174158        /// <summary> 
     
    220204        } 
    221205 
     206        /// <summary> 
     207        /// Gets the status of the task - whether it is being executed. 
     208        /// </summary> 
     209        public bool Executing { get; private set; } 
     210 
     211        /// <summary> 
     212        /// Gets whether this task is currently queued to run. This is true only 
     213        /// if the queue it is in is an explicit request, i.e will run when the 
     214        /// executor is idle. 
     215        /// </summary> 
     216        public bool Queued 
     217        { 
     218            get 
     219            { 
     220                if (Executor == null) 
     221                    throw new InvalidOperationException(); 
     222 
     223                return Executor.IsTaskQueued(this); 
     224            } 
     225        } 
     226 
     227        /// <summary> 
     228        /// Gets whether the task has been cancelled from execution. 
     229        /// </summary> 
     230        public bool Canceled 
     231        { 
     232            get; 
     233            private set; 
     234        } 
     235 
     236        /// <summary> 
     237        /// Cancels the task from running, or, if the task is queued for running, 
     238        /// removes the task from the queue. 
     239        /// </summary> 
     240        public void Cancel() 
     241        { 
     242            Executor.UnqueueTask(this); 
     243            Canceled = true; 
     244        } 
     245 
     246        /// <summary> 
     247        /// Executes the task in the context of the calling thread. 
     248        /// </summary> 
     249        public void Execute() 
     250        { 
     251            OnTaskStarted(); 
     252            Executing = true; 
     253            Canceled = false; 
     254            Progress = new SteppedProgressManager(); 
     255 
     256            try 
     257            { 
     258                //Run the task 
     259                foreach (IErasureTarget target in Targets) 
     260                    try 
     261                    { 
     262                        Progress.Steps.Add(new ErasureTargetProgressManagerStep( 
     263                            target, Targets.Count)); 
     264                        target.Execute(); 
     265                    } 
     266                    catch (FatalException) 
     267                    { 
     268                        throw; 
     269                    } 
     270                    catch (OperationCanceledException) 
     271                    { 
     272                        throw; 
     273                    } 
     274                    catch (SharingViolationException) 
     275                    { 
     276                    } 
     277            } 
     278            catch (FatalException e) 
     279            { 
     280                Logger.Log(e.Message, LogLevel.Fatal); 
     281            } 
     282            catch (OperationCanceledException e) 
     283            { 
     284                Logger.Log(e.Message, LogLevel.Fatal); 
     285            } 
     286            catch (SharingViolationException) 
     287            { 
     288            } 
     289            finally 
     290            { 
     291                //If the task is a recurring task, reschedule it since we are done. 
     292                if (Schedule is RecurringSchedule) 
     293                { 
     294                    ((RecurringSchedule)Schedule).Reschedule(DateTime.Now); 
     295                } 
     296 
     297                //If the task is an execute on restart task or run immediately task, it is 
     298                //only run once and can now be restored to a manually run task 
     299                if (Schedule == Schedule.RunOnRestart || Schedule == Schedule.RunNow) 
     300                    Schedule = Schedule.RunManually; 
     301 
     302                Progress = null; 
     303                Executing = false; 
     304                OnTaskFinished(); 
     305            } 
     306        } 
     307 
     308        private Executor executor; 
    222309        private Schedule schedule; 
    223310        private SteppedProgressManager progress; 
     
    235322 
    236323        /// <summary> 
    237         /// The event object holding all event handlers. 
    238         /// </summary> 
    239         public EventHandler<ProgressChangedEventArgs> ProgressChanged { get; set; } 
    240  
    241         /// <summary> 
    242324        /// The completion of the execution of a task. 
    243325        /// </summary> 
     
    256338        /// Broadcasts the task execution start event. 
    257339        /// </summary> 
    258         internal void OnTaskStarted() 
     340        private void OnTaskStarted() 
    259341        { 
    260342            if (TaskStarted != null) 
    261343                TaskStarted(this, EventArgs.Empty); 
    262             Executing = true; 
    263             Progress = new SteppedProgressManager(); 
    264         } 
    265  
    266         /// <summary> 
    267         /// Broadcasts a ProgressChanged event. The sender will be the erasure target 
    268         /// which broadcast this event; e.UserState will contain extra information 
    269         /// about the progress which is stored as a TaskProgressChangedEventArgs 
    270         /// object. 
    271         /// </summary> 
    272         /// <param name="sender">The <see cref="ErasureTarget"/> which is reporting 
    273         /// progress.</param> 
    274         /// <param name="e">The new progress value.</param> 
    275         /// <exception cref="ArgumentException">e.UserState must be of the type 
    276         /// <see cref="TaskProgressEventargs"/></exception> 
    277         /// <exception cref="ArgumentNullException">Both sender and e cannot be null.</exception> 
    278         internal void OnProgressChanged(ErasureTarget sender, ProgressChangedEventArgs e) 
    279         { 
    280             if (sender == null) 
    281                 throw new ArgumentNullException("sender"); 
    282             if (e == null) 
    283                 throw new ArgumentNullException("sender"); 
    284             if (e.UserState.GetType() != typeof(TaskProgressChangedEventArgs)) 
    285                 throw new ArgumentException("The Task.OnProgressChanged event expects a " + 
    286                     "TaskProgressEventArgs argument for the ProgressChangedEventArgs' UserState " + 
    287                     "object.", "e"); 
    288  
    289             if (ProgressChanged != null) 
    290                 ProgressChanged(sender, e); 
    291344        } 
    292345 
     
    294347        /// Broadcasts the task execution completion event. 
    295348        /// </summary> 
    296         internal void OnTaskFinished() 
    297         { 
    298             Progress = null; 
    299             Executing = false; 
     349        private void OnTaskFinished() 
     350        { 
    300351            if (TaskFinished != null) 
    301352                TaskFinished(this, EventArgs.Empty); 
    302353        } 
    303354        #endregion 
     355    } 
     356 
     357    /// <summary> 
     358    /// Returns the progress of an erasure target, since that comprises the 
     359    /// steps of the Task Progress. 
     360    /// </summary> 
     361    public class ErasureTargetProgressManagerStep : SteppedProgressManagerStepBase 
     362    { 
     363        /// <summary> 
     364        /// Constructor. 
     365        /// </summary> 
     366        /// <param name="target">The erasure target represented by this object.</param> 
     367        /// <param name="steps">The number of targets in the task.</param> 
     368        public ErasureTargetProgressManagerStep(IErasureTarget target, int targets) 
     369            : base(1.0f / targets) 
     370        { 
     371            Target = target; 
     372        } 
     373 
     374        public override ProgressManagerBase Progress 
     375        { 
     376            get 
     377            { 
     378                ProgressManagerBase targetProgress = Target.Progress; 
     379                if (targetProgress != null) 
     380                    TargetProgress = targetProgress; 
     381 
     382                return TargetProgress; 
     383            } 
     384            set 
     385            { 
     386                throw new InvalidOperationException(); 
     387            } 
     388        } 
     389 
     390        /// <summary> 
     391        /// The erasure target represented by this step. 
     392        /// </summary> 
     393        public IErasureTarget Target 
     394        { 
     395            get; 
     396            private set; 
     397        } 
     398 
     399        /// <summary> 
     400        /// Caches a copy of the progress object for the Target. This is so that 
     401        /// for as long we our object is alive we can give valid information 
     402        /// (as required by the SteppedProgressManager class) 
     403        /// </summary> 
     404        private ProgressManagerBase TargetProgress; 
    304405    } 
    305406 
     
    323424        public Task Task { get; private set; } 
    324425    } 
    325  
    326     /// <summary> 
    327     /// Stores extra information in the <see cref="ProgressChangedEventArgs"/> 
    328     /// structure that is not conveyed in the ProgressManagerBase classes. 
    329     /// </summary> 
    330     public class TaskProgressChangedEventArgs 
    331     { 
    332         /// <summary> 
    333         /// Constructor. 
    334         /// </summary> 
    335         /// <param name="itemName">The item whose erasure progress is being erased.</param> 
    336         /// <param name="itemPass">The current pass number for this item.</param> 
    337         /// <param name="itemTotalPasses">The total number of passes to complete erasure 
    338         /// of this item.</param> 
    339         public TaskProgressChangedEventArgs(string itemName, int itemPass, 
    340             int itemTotalPasses) 
    341         { 
    342             ItemName = itemName; 
    343             ItemPass = itemPass; 
    344             ItemTotalPasses = itemTotalPasses; 
    345         } 
    346  
    347         /// <summary> 
    348         /// The file name of the item being erased. 
    349         /// </summary> 
    350         public string ItemName { get; private set; } 
    351  
    352         /// <summary> 
    353         /// The pass number of a multi-pass erasure method. 
    354         /// </summary> 
    355         public int ItemPass { get; private set; } 
    356  
    357         /// <summary> 
    358         /// The total number of passes to complete before this erasure method is 
    359         /// completed. 
    360         /// </summary> 
    361         public int ItemTotalPasses { get; private set; } 
    362     } 
    363426} 
  • trunk/eraser/Eraser.Shell/CtxMenu.cpp

    r2254 r2509  
    237237            VerbMenuIndices.push_back(ACTION_ERASE); 
    238238        } 
    239         if (applicableActions & ACTION_ERASE_ON_RESTART) 
    240         { 
    241             InsertMenu(hSubmenu, ACTION_ERASE_ON_RESTART, MF_BYPOSITION, uID++, 
    242                 LoadString(IDS_ACTION_ERASERESTART).c_str());       //Erase on Restart 
    243             VerbMenuIndices.push_back(ACTION_ERASE_ON_RESTART); 
    244         } 
    245239        if (applicableActions & ACTION_ERASE_UNUSED_SPACE) 
    246240        { 
     
    430424        case ACTION_ERASE: 
    431425            commandString = LoadString(IDS_HELPSTRING_ERASE); 
    432             break; 
    433         case ACTION_ERASE_ON_RESTART: 
    434             commandString = LoadString(IDS_HELPSTRING_ERASEONRESTART); 
    435426            break; 
    436427        case ACTION_ERASE_UNUSED_SPACE: 
     
    468459            return E_INVALIDARG; 
    469460 
     461        //Show a busy cursor. 
     462        BusyCursor cursor; 
     463 
    470464        //Build the command line 
     465        bool commandElevate = false; 
     466        bool commandConfirm = true; 
    471467        std::wstring commandLine; 
    472         bool commandElevate = false; 
    473468        switch (VerbMenuIndices[LOWORD(pCmdInfo->lpVerb)]) 
    474469        { 
    475         case ACTION_ERASE_ON_RESTART: 
    476470        case ACTION_ERASE: 
    477             //See the invocation context: if it is executed from the recycle bin 
    478             //then the list of selected files will be empty. 
    479             if (InvokeReason == INVOKEREASON_RECYCLEBIN) 
    480             { 
    481                 commandLine += L"/recycleBin"; 
    482             } 
    483  
     471            commandLine = GenerateEraseCommand(); 
    484472            break; 
    485473 
    486474        case ACTION_ERASE_UNUSED_SPACE: 
    487475            //Erasing unused space requires elevation 
    488             commandElevate = true; 
     476            commandLine = GenerateEraseUnusedSpaceCommand(); 
    489477            break; 
    490478 
     
    520508            if (*DragDropDestinationDirectory.rbegin() == '\\') 
    521509                DragDropDestinationDirectory += '\\'; 
    522             commandLine += L"\"/destination=" + DragDropDestinationDirectory + L"\""; 
     510            commandLine = GenerateSecureMoveCommand(); 
    523511            break; 
    524512 
     
    528516                if (*DragDropDestinationDirectory.rbegin() == '\\') 
    529517                    DragDropDestinationDirectory += '\\'; 
    530                 commandLine += L"\"/destination=" + DragDropDestinationDirectory + L"\""; 
    531518 
    532519                //Query the files from the clipboard. 
     
    540527                    EmptyClipboard(); 
    541528                    CloseClipboard(); 
     529                    commandLine = GenerateSecureMoveCommand(); 
    542530                } 
    543531            } 
     
    554542        } 
    555543 
    556         //Add the list of items selected. 
    557         for (std::list<std::wstring>::const_iterator i = SelectedFiles.begin(); 
    558             i != SelectedFiles.end(); ++i) 
    559         { 
    560             std::wstring path(*i); 
    561             if (path[path.length() - 1] == '\\') 
    562                 path += '\\'; 
    563             commandLine += L" \"" + path + L"\""; 
    564         } 
    565  
    566544        try 
    567545        { 
    568             BusyCursor cursor; 
    569             RunEraser(VerbMenuIndices[LOWORD(pCmdInfo->lpVerb)], commandLine, commandElevate, 
    570                 pCmdInfo->hwnd, pCmdInfo->nShow); 
     546            RunEraser(commandLine, commandElevate, commandConfirm, pCmdInfo->hwnd, pCmdInfo->nShow); 
    571547        } 
    572548        catch (const std::wstring& e) 
     
    591567        { 
    592568        case INVOKEREASON_RECYCLEBIN: 
    593             result |= ACTION_ERASE | ACTION_ERASE_ON_RESTART; 
     569            result |= ACTION_ERASE; 
    594570            break; 
    595571        case INVOKEREASON_FILEFOLDER: 
    596             result |= ACTION_ERASE | ACTION_ERASE_ON_RESTART | ACTION_ERASE_UNUSED_SPACE; 
     572            result |= ACTION_ERASE | ACTION_ERASE_UNUSED_SPACE; 
    597573        case INVOKEREASON_DRAGDROP: 
    598574            result |= ACTION_SECURE_MOVE; 
     
    875851    } 
    876852 
    877     void CCtxMenu::RunEraser(Actions action, const std::wstring& parameters, bool elevated, 
     853    std::wstring CCtxMenu::GenerateEraseCommand() 
     854    { 
     855        std::wstring commandLine; 
     856 
     857        //See the invocation context: if it is executed from the recycle bin 
     858        //then the list of selected files will be empty. 
     859        if (InvokeReason == INVOKEREASON_RECYCLEBIN) 
     860        { 
     861            commandLine += L"recyclebin "; 
     862        } 
     863 
     864        //Add the list of items selected. 
     865        for (std::list<std::wstring>::const_iterator i = SelectedFiles.begin(); 
     866            i != SelectedFiles.end(); ++i) 
     867        { 
     868            std::wstring path(*i); 
     869            if (path[path.length() - 1] == '\\') 
     870                path += '\\'; 
     871 
     872            DWORD attributes = GetFileAttributes(path.c_str()); 
     873            if (attributes == INVALID_FILE_ATTRIBUTES) 
     874                continue; 
     875            else if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) 
     876                commandLine += L"\"file=" + path + L"\" "; 
     877            else 
     878                commandLine += L"\"dir=" + path + L"\" "; 
     879        } 
     880 
     881        return commandLine; 
     882    } 
     883 
     884    std::wstring CCtxMenu::GenerateEraseUnusedSpaceCommand() 
     885    { 
     886        std::wstring commandLine; 
     887 
     888        //Add the list of items selected. 
     889        for (std::list<std::wstring>::const_iterator i = SelectedFiles.begin(); 
     890            i != SelectedFiles.end(); ++i) 
     891        { 
     892            std::wstring path(*i); 
     893            if (path[path.length() - 1] == '\\') 
     894                path += '\\'; 
     895 
     896            commandLine += L"\"unused=" + path + L"\" "; 
     897        } 
     898 
     899        return commandLine; 
     900    } 
     901 
     902    std::wstring CCtxMenu::GenerateSecureMoveCommand() 
     903    { 
     904        std::wstring commandLine; 
     905 
     906        //Add the list of items selected. 
     907        for (std::list<std::wstring>::const_iterator i = SelectedFiles.begin(); 
     908            i != SelectedFiles.end(); ++i) 
     909        { 
     910            std::wstring path(*i); 
     911            if (path[path.length() - 1] == '\\') 
     912                path += '\\'; 
     913 
     914            commandLine += L"\"move=" + path + L"|" + DragDropDestinationDirectory + L"\" "; 
     915        } 
     916 
     917        return commandLine; 
     918    } 
     919 
     920    void CCtxMenu::RunEraser(const std::wstring& parameters, bool confirm, bool elevated, 
    878921        HWND parent, int show) 
    879922    { 
     
    900943        std::wostringstream finalParameters; 
    901944        finalParameters << L"shell /quiet "; 
    902  
    903         //Set the action selected by the user. 
    904         switch (action) 
    905         { 
    906         case ACTION_ERASE: 
    907             finalParameters << L"/action=EraseNow "; 
    908             break; 
    909         case ACTION_ERASE_ON_RESTART: 
    910             finalParameters << L"/action=EraseOnRestart "; 
    911             break; 
    912         case ACTION_ERASE_UNUSED_SPACE: 
    913             finalParameters << L"/action=EraseUnusedSpace "; 
    914             break; 
    915         case ACTION_SECURE_MOVE: 
    916         case ACTION_SECURE_PASTE: 
    917             finalParameters << L"/action=SecureMove "; 
    918             break; 
    919         default: 
    920             return; 
    921         } 
     945        if (!confirm) 
     946            finalParameters << L"/confirm=false "; 
    922947 
    923948        //Pass Explorer's HWND to the child process, in the event that it is required. 
     
    10121037                //Or if elevation is required for this operation 
    10131038                else if (GetLastError() == ERROR_ELEVATION_REQUIRED) 
    1014                     return RunEraser(action, parameters, true, parent, show); 
     1039                    return RunEraser(parameters, confirm, true, parent, show); 
    10151040 
    10161041                //Or otherwise? 
  • trunk/eraser/Eraser.Shell/CtxMenu.h

    r2120 r2509  
    5959        { 
    6060            ACTION_ERASE                = 1 << 0, 
    61             ACTION_ERASE_ON_RESTART     = 1 << 1, 
    62             ACTION_ERASE_UNUSED_SPACE   = 1 << 2, 
     61            ACTION_ERASE_UNUSED_SPACE   = 1 << 1, 
    6362            ACTION_SEPERATOR_1, 
    64             ACTION_SECURE_MOVE          = 1 << 3, 
    65             ACTION_SECURE_PASTE         = 1 << 4 
     63            ACTION_SECURE_MOVE          = 1 << 2, 
     64            ACTION_SECURE_PASTE         = 1 << 3 
    6665        }; 
    6766 
     
    8382        Actions GetApplicableActions(); 
    8483 
     84        std::wstring GenerateEraseCommand(); 
     85        std::wstring GenerateEraseUnusedSpaceCommand(); 
     86        std::wstring GenerateSecureMoveCommand(); 
     87 
    8588        static std::wstring LoadString(UINT stringID); 
    8689        static std::wstring FormatString(const std::wstring& formatString, ...); 
     
    9093 
    9194        static bool IsUserAdmin(); 
    92         static void RunEraser(Actions action, const std::wstring& parameters, 
    93             bool elevated, HWND parent, int show); 
     95        static void RunEraser(const std::wstring& parameters, bool confirm, bool elevated, 
     96            HWND parent, int show); 
    9497 
    9598        static void InsertSeparator(HMENU menu); 
  • trunk/eraser/Eraser.Util/Eraser.Util.csproj

    r2322 r2509  
    128128    <Compile Include="NativeMethods\Gdi.cs" /> 
    129129    <Compile Include="NativeMethods\Sfc.cs" /> 
    130     <Compile Include="ProgressManager.cs" /> 
    131130    <Compile Include="Sampler.cs" /> 
    132131    <Compile Include="ExtensionClasses\SharingViolationException.cs" /> 
  • trunk/eraser/Eraser.sln

    r2320 r2509  
    4646EndProject 
    4747Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Eraser.BlackBox", "Eraser.BlackBox\Eraser.BlackBox.csproj", "{F8C3524E-B846-454B-BA41-5E2AA64BD56B}" 
     48EndProject 
     49Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Eraser.Plugins", "Eraser.Plugins\Eraser.Plugins.csproj", "{59F7ED0F-3589-4112-B612-4A9A6588F4A0}" 
    4850EndProject 
    4951Global 
     
    182184        {F8C3524E-B846-454B-BA41-5E2AA64BD56B}.Release|x64.ActiveCfg = Release|Any CPU 
    183185        {F8C3524E-B846-454B-BA41-5E2AA64BD56B}.Release|x64.Build.0 = Release|Any CPU 
     186        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU 
     187        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Debug|Any CPU.Build.0 = Debug|Any CPU 
     188        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU 
     189        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU 
     190        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Debug|Win32.ActiveCfg = Debug|Any CPU 
     191        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Debug|Win32.Build.0 = Debug|Any CPU 
     192        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Debug|x64.ActiveCfg = Debug|Any CPU 
     193        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Debug|x64.Build.0 = Debug|Any CPU 
     194        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Release|Any CPU.ActiveCfg = Release|Any CPU 
     195        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Release|Any CPU.Build.0 = Release|Any CPU 
     196        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU 
     197        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Release|Mixed Platforms.Build.0 = Release|Any CPU 
     198        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Release|Win32.ActiveCfg = Release|Any CPU 
     199        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Release|Win32.Build.0 = Release|Any CPU 
     200        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Release|x64.ActiveCfg = Release|Any CPU 
     201        {59F7ED0F-3589-4112-B612-4A9A6588F4A0}.Release|x64.Build.0 = Release|Any CPU 
    184202    EndGlobalSection 
    185203    GlobalSection(SolutionProperties) = preSolution 
  • trunk/eraser/Eraser/Eraser.csproj

    r2320 r2509  
    225225    <EmbeddedResource Include="Strings.en.resx"> 
    226226      <SubType>Designer</SubType> 
    227     </EmbeddedResource> 
    228     <EmbeddedResource Include="Strings.it.resx" /> 
    229     <EmbeddedResource Include="Strings.pl.resx" /> 
     227      <Generator>ResXFileCodeGenerator</Generator> 
     228      <LastGenOutput>Strings.en.Designer.cs</LastGenOutput> 
     229    </EmbeddedResource> 
     230    <EmbeddedResource Include="Strings.it.resx"> 
     231      <Generator>ResXFileCodeGenerator</Generator> 
     232      <LastGenOutput>Strings.it.Designer.cs</LastGenOutput> 
     233    </EmbeddedResource> 
     234    <EmbeddedResource Include="Strings.pl.resx"> 
     235      <Generator>ResXFileCodeGenerator</Generator> 
     236      <LastGenOutput>Strings.pl.Designer.cs</LastGenOutput> 
     237    </EmbeddedResource> 
    230238    <EmbeddedResource Include="Strings.resx"> 
    231239      <SubType>Designer</SubType> 
    232240      <LastGenOutput>Strings.Designer.cs</LastGenOutput> 
     241      <Generator>ResXFileCodeGenerator</Generator> 
    233242    </EmbeddedResource> 
    234243    <EmbeddedResource Include="Strings.nl.resx"> 
    235244      <SubType>Designer</SubType> 
    236245      <LastGenOutput>Strings.nl.Designer.cs</LastGenOutput> 
     246      <Generator>ResXFileCodeGenerator</Generator> 
    237247    </EmbeddedResource> 
    238248    <EmbeddedResource Include="SchedulerPanel.resx"> 
     
    369379  </ItemGroup> 
    370380  <ItemGroup> 
    371     <ProjectReference Include="..\Eraser.DefaultPlugins\Eraser.DefaultPlugins.csproj"> 
    372       <Project>{21752123-7BD7-4B44-B512-14A963C55FD8}</Project> 
    373       <Name>Eraser.DefaultPlugins</Name> 
    374       <Private>False</Private> 
    375     </ProjectReference> 
    376381    <ProjectReference Include="..\Eraser.Manager\Eraser.Manager.csproj"> 
    377382      <Project>{C1AC3255-0939-499D-A69D-725E3DD4F574}</Project> 
    378383      <Name>Eraser.Manager</Name> 
     384    </ProjectReference> 
     385    <ProjectReference Include="..\Eraser.Plugins\Eraser.Plugins.csproj"> 
     386      <Project>{59F7ED0F-3589-4112-B612-4A9A6588F4A0}</Project> 
     387      <Name>Eraser.Plugins</Name> 
    379388    </ProjectReference> 
    380389    <ProjectReference Include="..\Eraser.Util\Eraser.Util.csproj"> 
  • trunk/eraser/Eraser/LogForm.cs

    r1886 r2509  
    4343 
    4444            //Update the title 
    45             Text = string.Format(CultureInfo.InvariantCulture, "{0} - {1}", Text, task.UIText); 
     45            Text = string.Format(CultureInfo.InvariantCulture, "{0} - {1}", Text, task); 
    4646 
    4747            //Populate the list of sessions 
  • trunk/eraser/Eraser/MainForm.Designer.cs

    r1822 r2509  
    6868            this.exportTaskListToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); 
    6969            this.importTaskListToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); 
     70            this.tbTools = new System.Windows.Forms.ToolStripMenuItem(); 
     71            this.tbToolsDropDown = new System.Windows.Forms.ToolStripMenuItem(); 
    7072            this.tbSettings = new System.Windows.Forms.ToolStripMenuItem(); 
    7173            this.tbHelp = new System.Windows.Forms.ToolStripMenuItem(); 
     
    7678            this.checkForUpdatesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); 
    7779            this.eraserLogo = new System.Windows.Forms.PictureBox(); 
     80            this.tbToolsMenu = new System.Windows.Forms.ContextMenuStrip(this.components); 
    7881            this.notificationMenu.SuspendLayout(); 
    7982            this.ToolBar.SuspendLayout(); 
     
    8588            // contentPanel 
    8689            //  
    87             this.contentPanel.AccessibleDescription = null; 
    88             this.contentPanel.AccessibleName = null; 
    8990            resources.ApplyResources(this.contentPanel, "contentPanel"); 
    9091            this.contentPanel.BackColor = System.Drawing.Color.White; 
    91             this.contentPanel.BackgroundImage = null; 
    92             this.contentPanel.Font = null; 
    9392            this.contentPanel.Name = "contentPanel"; 
    9493            //  
    9594            // tbSchedule 
    9695            //  
    97             this.tbSchedule.AccessibleDescription = null; 
    98             this.tbSchedule.AccessibleName = null; 
    99             resources.ApplyResources(this.tbSchedule, "tbSchedule"); 
    100             this.tbSchedule.BackgroundImage = null; 
    10196            this.tbSchedule.Image = global::Eraser.Properties.Resources.ToolbarSchedule; 
    10297            this.tbSchedule.Name = "tbSchedule"; 
    10398            this.tbSchedule.Padding = new System.Windows.Forms.Padding(0); 
    104             this.tbSchedule.ShortcutKeyDisplayString = null; 
     99            resources.ApplyResources(this.tbSchedule, "tbSchedule"); 
    105100            this.tbSchedule.Click += new System.EventHandler(this.tbSchedule_Click); 
    106101            //  
    107102            // notificationIcon 
    108103            //  
     104            this.notificationIcon.ContextMenuStrip = this.notificationMenu; 
    109105            resources.ApplyResources(this.notificationIcon, "notificationIcon"); 
    110             this.notificationIcon.ContextMenuStrip = this.notificationMenu; 
    111106            this.notificationIcon.DoubleClick += new System.EventHandler(this.openToolStripMenuItem_Click); 
    112107            //  
    113108            // notificationMenu 
    114109            //  
    115             this.notificationMenu.AccessibleDescription = null; 
    116             this.notificationMenu.AccessibleName = null; 
    117             resources.ApplyResources(this.notificationMenu, "notificationMenu"); 
    118             this.notificationMenu.BackgroundImage = null; 
    119             this.notificationMenu.Font = null; 
    120110            this.notificationMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { 
    121111            this.openEraserToolStripMenuItem, 
     
    124114            this.exitToolStripMenuItem}); 
    125115            this.notificationMenu.Name = "notificationMenu"; 
     116            resources.ApplyResources(this.notificationMenu, "notificationMenu"); 
    126117            //  
    127118            // openEraserToolStripMenuItem 
    128119            //  
    129             this.openEraserToolStripMenuItem.AccessibleDescription = null; 
    130             this.openEraserToolStripMenuItem.AccessibleName = null; 
    131120            resources.ApplyResources(this.openEraserToolStripMenuItem, "openEraserToolStripMenuItem"); 
    132             this.openEraserToolStripMenuItem.BackgroundImage = null; 
    133121            this.openEraserToolStripMenuItem.Name = "openEraserToolStripMenuItem"; 
    134             this.openEraserToolStripMenuItem.ShortcutKeyDisplayString = null; 
    135122            this.openEraserToolStripMenuItem.Click += new System.EventHandler(this.openToolStripMenuItem_Click); 
    136123            //  
    137124            // toolStripMenuItem1 
    138125            //  
    139             this.toolStripMenuItem1.AccessibleDescription = null; 
    140             this.toolStripMenuItem1.AccessibleName = null; 
     126            this.toolStripMenuItem1.Name = "toolStripMenuItem1"; 
    141127            resources.ApplyResources(this.toolStripMenuItem1, "toolStripMenuItem1"); 
    142             this.toolStripMenuItem1.Name = "toolStripMenuItem1"; 
    143128            //  
    144129            // hideWhenMinimisedToolStripMenuItem 
    145130            //  
    146             this.hideWhenMinimisedToolStripMenuItem.AccessibleDescription = null; 
    147             this.hideWhenMinimisedToolStripMenuItem.AccessibleName = null; 
    148             resources.ApplyResources(this.hideWhenMinimisedToolStripMenuItem, "hideWhenMinimisedToolStripMenuItem"); 
    149             this.hideWhenMinimisedToolStripMenuItem.BackgroundImage = null; 
    150131            this.hideWhenMinimisedToolStripMenuItem.CheckOnClick = true; 
    151132            this.hideWhenMinimisedToolStripMenuItem.Name = "hideWhenMinimisedToolStripMenuItem"; 
    152             this.hideWhenMinimisedToolStripMenuItem.ShortcutKeyDisplayString = null; 
     133            resources.ApplyResources(this.hideWhenMinimisedToolStripMenuItem, "hideWhenMinimisedToolStripMenuItem"); 
    153134            this.hideWhenMinimisedToolStripMenuItem.Click += new System.EventHandler(this.hideWhenMinimiseToolStripMenuItem_Click); 
    154135            //  
    155136            // exitToolStripMenuItem 
    156137            //  
    157             this.exitToolStripMenuItem.AccessibleDescription = null; 
    158             this.exitToolStripMenuItem.AccessibleName = null; 
     138            this.exitToolStripMenuItem.Name = "exitToolStripMenuItem"; 
    159139            resources.ApplyResources(this.exitToolStripMenuItem, "exitToolStripMenuItem"); 
    160             this.exitToolStripMenuItem.BackgroundImage = null; 
    161             this.exitToolStripMenuItem.Name = "exitToolStripMenuItem"; 
    162             this.exitToolStripMenuItem.ShortcutKeyDisplayString = null; 
    163140            this.exitToolStripMenuItem.Click += new System.EventHandler(this.exitToolStripMenuItem_Click); 
    164141            //  
     
    169146            // ToolBar 
    170147            //  
    171             this.ToolBar.AccessibleDescription = null; 
    172             this.ToolBar.AccessibleName = null; 
    173148            this.ToolBar.AllowItemReorder = true; 
     149            this.ToolBar.BackColor = System.Drawing.Color.Transparent; 
    174150            resources.ApplyResources(this.ToolBar, "ToolBar"); 
    175             this.ToolBar.BackColor = System.Drawing.Color.Transparent; 
    176             this.ToolBar.BackgroundImage = null; 
    177             this.ToolBar.Font = null; 
    178151            this.ToolBar.ImageScalingSize = new System.Drawing.Size(24, 24); 
    179152            this.ToolBar.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { 
    180153            this.tbSchedule, 
    181154            this.tbScheduleDropDown, 
     155            this.tbTools, 
     156            this.tbToolsDropDown, 
    182157            this.tbSettings, 
    183158            this.tbHelp, 
     
    187162            // tbScheduleDropDown 
    188163            //  
    189             this.tbScheduleDropDown.AccessibleDescription = null; 
    190             this.tbScheduleDropDown.AccessibleName = null; 
    191             resources.ApplyResources(this.tbScheduleDropDown, "tbScheduleDropDown"); 
    192             this.tbScheduleDropDown.BackgroundImage = null; 
    193164            this.tbScheduleDropDown.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; 
    194165            this.tbScheduleDropDown.DropDown = this.tbScheduleMenu; 
    195166            this.tbScheduleDropDown.Image = global::Eraser.Properties.Resources.ToolbarArrow; 
     167            resources.ApplyResources(this.tbScheduleDropDown, "tbScheduleDropDown"); 
    196168            this.tbScheduleDropDown.Margin = new System.Windows.Forms.Padding(0, 0, 10, 0); 
    197169            this.tbScheduleDropDown.Name = "tbScheduleDropDown"; 
    198170            this.tbScheduleDropDown.Padding = new System.Windows.Forms.Padding(0); 
    199             this.tbScheduleDropDown.ShortcutKeyDisplayString = null; 
    200171            //  
    201172            // tbScheduleMenu 
    202173            //  
    203             this.tbScheduleMenu.AccessibleDescription = null; 
    204             this.tbScheduleMenu.AccessibleName = null; 
    205             resources.ApplyResources(this.tbScheduleMenu, "tbScheduleMenu"); 
    206             this.tbScheduleMenu.BackgroundImage = null; 
    207             this.tbScheduleMenu.Font = null; 
    208174            this.tbScheduleMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { 
    209175            this.newTaskToolStripMenuItem, 
     
    212178            this.importTaskListToolStripMenuItem}); 
    213179            this.tbScheduleMenu.Name = "tbScheduleMenu"; 
    214             this.tbScheduleMenu.OwnerItem = this.tbScheduleDropDown; 
     180            resources.ApplyResources(this.tbScheduleMenu, "tbScheduleMenu"); 
    215181            //  
    216182            // newTaskToolStripMenuItem 
    217183            //  
    218             this.newTaskToolStripMenuItem.AccessibleDescription = null; 
    219             this.newTaskToolStripMenuItem.AccessibleName = null; 
     184            this.newTaskToolStripMenuItem.Name = "newTaskToolStripMenuItem"; 
    220185            resources.ApplyResources(this.newTaskToolStripMenuItem, "newTaskToolStripMenuItem"); 
    221             this.newTaskToolStripMenuItem.BackgroundImage = null; 
    222             this.newTaskToolStripMenuItem.Name = "newTaskToolStripMenuItem"; 
    223             this.newTaskToolStripMenuItem.ShortcutKeyDisplayString = null; 
    224186            this.newTaskToolStripMenuItem.Click += new System.EventHandler(this.newTaskToolStripMenuItem_Click); 
    225187            //  
    226188            // toolStripMenuItem2 
    227189            //  
    228             this.toolStripMenuItem2.AccessibleDescription = null; 
    229             this.toolStripMenuItem2.AccessibleName = null; 
     190            this.toolStripMenuItem2.Name = "toolStripMenuItem2"; 
    230191            resources.ApplyResources(this.toolStripMenuItem2, "toolStripMenuItem2"); 
    231             this.toolStripMenuItem2.Name = "toolStripMenuItem2"; 
    232192            //  
    233193            // exportTaskListToolStripMenuItem 
    234194            //  
    235             this.exportTaskListToolStripMenuItem.AccessibleDescription = null; 
    236             this.exportTaskListToolStripMenuItem.AccessibleName = null; 
     195            this.exportTaskListToolStripMenuItem.Name = "exportTaskListToolStripMenuItem"; 
    237196            resources.ApplyResources(this.exportTaskListToolStripMenuItem, "exportTaskListToolStripMenuItem"); 
    238             this.exportTaskListToolStripMenuItem.BackgroundImage = null; 
    239             this.exportTaskListToolStripMenuItem.Name = "exportTaskListToolStripMenuItem"; 
    240             this.exportTaskListToolStripMenuItem.ShortcutKeyDisplayString = null; 
    241197            this.exportTaskListToolStripMenuItem.Click += new System.EventHandler(this.exportTaskListToolStripMenuItem_Click); 
    242198            //  
    243199            // importTaskListToolStripMenuItem 
    244200            //  
    245             this.importTaskListToolStripMenuItem.AccessibleDescription = null; 
    246             this.importTaskListToolStripMenuItem.AccessibleName = null; 
     201            this.importTaskListToolStripMenuItem.Name = "importTaskListToolStripMenuItem"; 
    247202            resources.ApplyResources(this.importTaskListToolStripMenuItem, "importTaskListToolStripMenuItem"); 
    248             this.importTaskListToolStripMenuItem.BackgroundImage = null; 
    249             this.importTaskListToolStripMenuItem.Name = "importTaskListToolStripMenuItem"; 
    250             this.importTaskListToolStripMenuItem.ShortcutKeyDisplayString = null; 
    251203            this.importTaskListToolStripMenuItem.Click += new System.EventHandler(this.importTaskListToolStripMenuItem_Click); 
    252204            //  
     205            // tbTools 
     206            //  
     207            this.tbTools.Name = "tbTools"; 
     208            resources.ApplyResources(this.tbTools, "tbTools"); 
     209            //  
     210            // tbToolsDropDown 
     211            //  
     212            this.tbToolsDropDown.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; 
     213            this.tbToolsDropDown.DropDown = this.tbToolsMenu; 
     214            this.tbToolsDropDown.Image = global::Eraser.Properties.Resources.ToolbarArrow; 
     215            resources.ApplyResources(this.tbToolsDropDown, "tbToolsDropDown"); 
     216            this.tbToolsDropDown.Margin = new System.Windows.Forms.Padding(0, 0, 10, 0); 
     217            this.tbToolsDropDown.Name = "tbToolsDropDown"; 
     218            //  
    253219            // tbSettings 
    254220            //  
    255             this.tbSettings.AccessibleDescription = null; 
    256             this.tbSettings.AccessibleName = null; 
    257             resources.ApplyResources(this.tbSettings, "tbSettings"); 
    258             this.tbSettings.BackgroundImage = null; 
    259221            this.tbSettings.Image = global::Eraser.Properties.Resources.ToolbarSettings; 
    260222            this.tbSettings.Margin = new System.Windows.Forms.Padding(0, 0, 10, 0); 
    261223            this.tbSettings.Name = "tbSettings"; 
    262224            this.tbSettings.Padding = new System.Windows.Forms.Padding(0); 
    263             this.tbSettings.ShortcutKeyDisplayString = null; 
     225            resources.ApplyResources(this.tbSettings, "tbSettings"); 
    264226            this.tbSettings.Click += new System.EventHandler(this.tbSettings_Click); 
    265227            //  
    266228            // tbHelp 
    267229            //  
    268             this.tbHelp.AccessibleDescription = null; 
    269             this.tbHelp.AccessibleName = null; 
    270             resources.ApplyResources(this.tbHelp, "tbHelp"); 
    271             this.tbHelp.BackgroundImage = null; 
    272230            this.tbHelp.Image = global::Eraser.Properties.Resources.ToolbarHelp; 
    273231            this.tbHelp.Name = "tbHelp"; 
    274232            this.tbHelp.Padding = new System.Windows.Forms.Padding(0); 
    275             this.tbHelp.ShortcutKeyDisplayString = null; 
     233            resources.ApplyResources(this.tbHelp, "tbHelp"); 
    276234            this.tbHelp.Click += new System.EventHandler(this.tbHelp_Click); 
    277235            //  
    278236            // tbHelpDropDown 
    279237            //  
    280             this.tbHelpDropDown.AccessibleDescription = null; 
    281             this.tbHelpDropDown.AccessibleName = null; 
    282             resources.ApplyResources(this.tbHelpDropDown, "tbHelpDropDown"); 
    283             this.tbHelpDropDown.BackgroundImage = null; 
    284238            this.tbHelpDropDown.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; 
    285239            this.tbHelpDropDown.DropDown = this.tbHelpMenu; 
    286240            this.tbHelpDropDown.Image = global::Eraser.Properties.Resources.ToolbarArrow; 
     241            resources.ApplyResources(this.tbHelpDropDown, "tbHelpDropDown"); 
    287242            this.tbHelpDropDown.Name = "tbHelpDropDown"; 
    288243            this.tbHelpDropDown.Padding = new System.Windows.Forms.Padding(0); 
    289             this.tbHelpDropDown.ShortcutKeyDisplayString = null; 
    290244            //  
    291245            // tbHelpMenu 
    292246            //  
    293             this.tbHelpMenu.AccessibleDescription = null; 
    294             this.tbHelpMenu.AccessibleName = null; 
    295             resources.ApplyResources(this.tbHelpMenu, "tbHelpMenu"); 
    296             this.tbHelpMenu.BackgroundImage = null; 
    297             this.tbHelpMenu.Font = null; 
    298247            this.tbHelpMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { 
    299248            this.checkForUpdatesToolStripMenuItem1, 
    300249            this.aboutEraserToolStripMenuItem}); 
    301250            this.tbHelpMenu.Name = "tbHelpMenu"; 
    302             this.tbHelpMenu.OwnerItem = this.tbHelpDropDown; 
     251            resources.ApplyResources(this.tbHelpMenu, "tbHelpMenu"); 
    303252            //  
    304253            // checkForUpdatesToolStripMenuItem1 
    305254            //  
    306             this.checkForUpdatesToolStripMenuItem1.AccessibleDescription = null; 
    307             this.checkForUpdatesToolStripMenuItem1.AccessibleName = null; 
     255            this.checkForUpdatesToolStripMenuItem1.Name = "checkForUpdatesToolStripMenuItem1"; 
    308256            resources.ApplyResources(this.checkForUpdatesToolStripMenuItem1, "checkForUpdatesToolStripMenuItem1"); 
    309             this.checkForUpdatesToolStripMenuItem1.BackgroundImage = null; 
    310             this.checkForUpdatesToolStripMenuItem1.Name = "checkForUpdatesToolStripMenuItem1"; 
    311             this.checkForUpdatesToolStripMenuItem1.ShortcutKeyDisplayString = null; 
    312257            this.checkForUpdatesToolStripMenuItem1.Click += new System.EventHandler(this.checkForUpdatesToolStripMenuItem_Click); 
    313258            //  
    314259            // aboutEraserToolStripMenuItem 
    315260            //  
    316             this.aboutEraserToolStripMenuItem.AccessibleDescription = null; 
    317             this.aboutEraserToolStripMenuItem.AccessibleName = null; 
     261            this.aboutEraserToolStripMenuItem.Name = "aboutEraserToolStripMenuItem"; 
    318262            resources.ApplyResources(this.aboutEraserToolStripMenuItem, "aboutEraserToolStripMenuItem"); 
    319             this.aboutEraserToolStripMenuItem.BackgroundImage = null; 
    320             this.aboutEraserToolStripMenuItem.Name = "aboutEraserToolStripMenuItem"; 
    321             this.aboutEraserToolStripMenuItem.ShortcutKeyDisplayString = null; 
    322263            this.aboutEraserToolStripMenuItem.Click += new System.EventHandler(this.aboutEraserToolStripMenuItem_Click); 
    323264            //  
    324265            // checkForUpdatesToolStripMenuItem 
    325266            //  
    326             this.checkForUpdatesToolStripMenuItem.AccessibleDescription = null; 
    327             this.checkForUpdatesToolStripMenuItem.AccessibleName = null; 
     267            this.checkForUpdatesToolStripMenuItem.Name = "checkForUpdatesToolStripMenuItem"; 
    328268            resources.ApplyResources(this.checkForUpdatesToolStripMenuItem, "checkForUpdatesToolStripMenuItem"); 
    329             this.checkForUpdatesToolStripMenuItem.BackgroundImage = null; 
    330             this.checkForUpdatesToolStripMenuItem.Name = "checkForUpdatesToolStripMenuItem"; 
    331             this.checkForUpdatesToolStripMenuItem.ShortcutKeyDisplayString = null; 
    332269            this.checkForUpdatesToolStripMenuItem.Click += new System.EventHandler(this.checkForUpdatesToolStripMenuItem_Click); 
    333270            //  
    334271            // eraserLogo 
    335272            //  
    336             this.eraserLogo.AccessibleDescription = null; 
    337             this.eraserLogo.AccessibleName = null; 
    338273            resources.ApplyResources(this.eraserLogo, "eraserLogo"); 
    339274            this.eraserLogo.BackColor = System.Drawing.Color.Transparent; 
    340             this.eraserLogo.BackgroundImage = null; 
    341275            this.eraserLogo.Cursor = System.Windows.Forms.Cursors.Hand; 
    342             this.eraserLogo.Font = null; 
    343276            this.eraserLogo.Image = global::Eraser.Properties.Resources.BackgroundLogo; 
    344             this.eraserLogo.ImageLocation = null; 
    345277            this.eraserLogo.Name = "eraserLogo"; 
    346278            this.eraserLogo.TabStop = false; 
    347279            this.eraserLogo.Click += new System.EventHandler(this.eraserLogo_Click); 
    348280            //  
     281            // tbToolsMenu 
     282            //  
     283            this.tbToolsMenu.Name = "tbToolsMenu"; 
     284            resources.ApplyResources(this.tbToolsMenu, "tbToolsMenu"); 
     285            //  
    349286            // MainForm 
    350287            //  
    351             this.AccessibleDescription = null; 
    352             this.AccessibleName = null; 
    353288            resources.ApplyResources(this, "$this"); 
    354289            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; 
    355290            this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(41)))), ((int)(((byte)(41)))), ((int)(((byte)(41))))); 
    356             this.BackgroundImage = null; 
    357291            this.Controls.Add(this.eraserLogo); 
    358292            this.Controls.Add(this.contentPanel); 
     
    361295            this.MainMenuStrip = this.ToolBar; 
    362296            this.Name = "MainForm"; 
     297            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.MainForm_FormClosing); 
     298            this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.MainForm_FormClosed); 
     299            this.VisibleChanged += new System.EventHandler(this.MainForm_VisibleChanged); 
    363300            this.Paint += new System.Windows.Forms.PaintEventHandler(this.MainForm_Paint); 
    364             this.VisibleChanged += new System.EventHandler(this.MainForm_VisibleChanged); 
    365             this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.MainForm_FormClosed); 
    366             this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.MainForm_FormClosing); 
    367301            this.Resize += new System.EventHandler(this.MainForm_Resize); 
    368302            this.notificationMenu.ResumeLayout(false); 
     
    403337        private System.Windows.Forms.ToolStripMenuItem importTaskListToolStripMenuItem; 
    404338        private System.Windows.Forms.PictureBox eraserLogo; 
     339        private System.Windows.Forms.ToolStripMenuItem tbTools; 
     340        private System.Windows.Forms.ToolStripMenuItem tbToolsDropDown; 
     341        private System.Windows.Forms.ContextMenuStrip tbToolsMenu; 
    405342    } 
    406343} 
  • trunk/eraser/Eraser/MainForm.cs

    r2339 r2509  
    2828using System.Text; 
    2929using System.Windows.Forms; 
    30 using Eraser.Util; 
    31 using Eraser.Manager; 
    32 using Eraser.Properties; 
     30 
    3331using System.IO; 
    3432using System.Diagnostics; 
    3533using System.Reflection; 
    3634using System.Runtime.Serialization; 
     35 
     36using Eraser.Util; 
     37using Eraser.Manager; 
     38using Eraser.Plugins; 
     39using Eraser.Plugins.Registrars; 
     40using Eraser.Plugins.ExtensionPoints; 
     41using Eraser.Properties; 
    3742 
    3843namespace Eraser 
     
    5661            Theming.ApplyTheme(this); 
    5762            Theming.ApplyTheme(notificationMenu); 
     63 
     64            //We need to see if there are any tools to display 
     65            foreach (IClientTool tool in Host.Instance.ClientTools) 
     66                tool.RegisterTool(tbToolsMenu); 
     67            if (tbToolsMenu.Items.Count == 0) 
     68            { 
     69                //There are none, hide the menu 
     70                tbTools.Visible = false; 
     71                tbToolsDropDown.Visible = false; 
     72            } 
    5873 
    5974            //For every task we need to register the Task Started and Task Finished 
     
    365380 
    366381            Task task = (Task)sender; 
    367             string iconText = S._("Eraser") + " - " + S._("Processing:") + ' ' + task.UIText; 
     382            string iconText = S._("Eraser") + " - " + S._("Processing:") + ' ' + task.ToString(); 
    368383            if (iconText.Length >= 64) 
    369384                iconText = iconText.Remove(60) + "..."; 
  • trunk/eraser/Eraser/Program.cs

    r2267 r2509  
    3131using System.Security.Principal; 
    3232using System.Text.RegularExpressions; 
     33using System.Text; 
    3334 
    3435using System.Reflection; 
     
    3940using Eraser.Manager; 
    4041using Eraser.Util; 
    41 using Eraser.DefaultPlugins; 
    42 using System.Text; 
     42using Eraser.Plugins; 
     43using Eraser.Plugins.ExtensionPoints; 
     44using Eraser.Plugins.Registrars; 
    4345 
    4446namespace Eraser 
     
    133135        } 
    134136 
    135         class AddTaskArguments : EraseArguments 
     137        class TaskArguments : EraseArguments 
    136138        { 
    137139            /// <summary> 
    138140            /// Constructor. 
    139141            /// </summary> 
    140             public AddTaskArguments() 
    141             { 
    142             } 
    143  
    144             /// <summary> 
    145             /// Constructs Add Task arguments from Erase arguments. 
     142            public TaskArguments() 
     143            { 
     144            } 
     145 
     146            /// <summary> 
     147            /// Constructs Task arguments from Erase arguments. 
    146148            /// </summary> 
    147149            /// <param name="arguments">The <see cref="EraseArguments"/> to use as a template 
    148150            /// for this instance.</param> 
    149             internal AddTaskArguments(EraseArguments arguments) 
     151            internal TaskArguments(EraseArguments arguments) 
    150152                : base(arguments) 
    151153            { 
     
    159161        } 
    160162 
    161         class ShellArguments : ConsoleArguments 
    162         { 
    163             /// <summary> 
    164             /// The action which the shell extension has requested. 
    165             /// </summary> 
    166             [Arg("action", "The action selected by the user", typeof(string), true, null, null)] 
    167             public ShellActions ShellAction { get; set; } 
    168  
    169             /// <summary> 
    170             /// Whether the recycle bin was specified on the command line. 
    171             /// </summary> 
    172             [Arg("recycleBin", "The recycle bin as an erasure target", typeof(string), false, null, null)] 
    173             public bool RecycleBin { get; set; } 
    174  
    175             /// <summary> 
    176             /// The destination for secure move operations, only valid when 
    177             /// <see cref="ShellAction"/> is <see cref="ShellActions.SecureMove"/> 
    178             /// </summary> 
    179             [Arg("destination", "The destination for secure move operations", typeof(string), false, null, null)] 
    180             public string Destination { get; set; } 
    181  
     163        class ShellArguments : TaskArguments 
     164        { 
    182165            /// <summary> 
    183166            /// The parent HWND which can be used as a parent to display dialogs. 
     
    185168            [Arg("parent", "The parent HWND which can be used as a parent to display dialogues", typeof(string), false, null, null)] 
    186169            public string Parent { get; set; } 
     170 
     171            /// <summary> 
     172            /// Whether we should display a confirmation dialog. 
     173            /// </summary> 
     174            [Arg("confirm", "Whether a confirmation dialog should be shown", typeof(bool), false, true, null)] 
     175            public bool Confirm { get; set; } 
    187176        } 
    188177 
     
    242231 
    243232            //Load the Eraser.Manager library 
    244             using (ManagerLibrary library = new ManagerLibrary(new Settings())) 
     233            using (ManagerLibrary library = new ManagerLibrary(Settings.Get())) 
    245234            { 
    246235                //Set our UI language 
     
    331320                        new ConsoleActionData(CommandErase, new EraseArguments()));  
    332321                    program.Handlers.Add("addtask", 
    333                         new ConsoleActionData(CommandAddTask, new AddTaskArguments())); 
     322                        new ConsoleActionData(CommandAddTask, new TaskArguments())); 
    334323                    program.Handlers.Add("importtasklist", 
    335324                        new ConsoleActionData(CommandImportTaskList, new ConsoleArguments())); 
     
    362351            //Get the command-line help for every erasure target 
    363352            StringBuilder targets = new StringBuilder(); 
    364             foreach (ErasureTarget target in ManagerLibrary.Instance.ErasureTargetRegistrar) 
     353            foreach (IErasureTarget target in Host.Instance.ErasureTargetFactories) 
    365354            { 
    366355                //Replace all \r\n with \n, and split into lines 
     
    379368 
    380369            //Generate the list of erasure methods. 
    381             foreach (ErasureMethod method in ManagerLibrary.Instance.ErasureMethodRegistrar) 
    382             { 
    383                 methods.AppendFormat(methodFormat, (method is UnusedSpaceErasureMethod) ? 
     370            foreach (IErasureMethod method in Host.Instance.ErasureTargetFactories) 
     371            { 
     372                methods.AppendFormat(methodFormat, (method is IUnusedSpaceErasureMethod) ? 
    384373                    "U" : "", method.Name, method.Guid); 
    385374            } 
     
    460449        private static void CommandErase(ConsoleArguments arg) 
    461450        { 
    462             AddTaskArguments arguments = new AddTaskArguments((EraseArguments)arg); 
     451            TaskArguments arguments = new TaskArguments((EraseArguments)arg); 
    463452            arguments.Schedule = "NOW"; 
    464453 
     
    473462        private static void CommandAddTask(ConsoleArguments arg) 
    474463        { 
    475             AddTaskArguments arguments = (AddTaskArguments)arg; 
    476  
     464            TaskArguments arguments = (TaskArguments)arg; 
     465            Task task = TaskFromCommandLine(arguments); 
     466 
     467            //Send the task out. 
     468            using (eraserClient = CommandConnect()) 
     469                eraserClient.Tasks.Add(task); 
     470        } 
     471 
     472        /// <summary> 
     473        /// Parses the command line for erasure targets and returns them as 
     474        /// a Task object. 
     475        /// </summary> 
     476        /// <param name="arguments">The arguments specified on the command line.</param> 
     477        /// <returns>The task represented on the command line.</returns> 
     478        private static Task TaskFromCommandLine(TaskArguments arguments) 
     479        { 
    477480            //Create the task 
    478481            Task task = new Task(); 
    479482 
    480483            //Get the erasure method the user wants to use 
    481             ErasureMethod method = string.IsNullOrEmpty(arguments.ErasureMethod) ? 
     484            IErasureMethod method = string.IsNullOrEmpty(arguments.ErasureMethod) ? 
    482485                ErasureMethodRegistrar.Default : 
    483486                ErasureMethodFromNameOrGuid(arguments.ErasureMethod); 
     
    504507            foreach (string argument in arguments.PositionalArguments) 
    505508            { 
    506                 ErasureTarget selectedTarget = null; 
     509                IErasureTarget selectedTarget = null; 
    507510 
    508511                //Iterate over every defined erasure target 
    509                 foreach (ErasureTarget target in ManagerLibrary.Instance.ErasureTargetRegistrar) 
     512                foreach (IErasureTarget target in Host.Instance.ErasureTargetFactories) 
    510513                { 
    511514                    //See if this argument can be handled by the target's configurer 
     
    545548                throw new ArgumentException(S._("Tasks must contain at least one erasure target.")); 
    546549 
    547             //Send the task out. 
    548             using (eraserClient = CommandConnect()) 
    549                 eraserClient.Tasks.Add(task); 
    550         } 
    551  
    552         private static ErasureMethod ErasureMethodFromNameOrGuid(string param) 
     550            return task; 
     551        } 
     552 
     553        private static IErasureMethod ErasureMethodFromNameOrGuid(string param) 
    553554        { 
    554555            try 
    555556            { 
    556                 return ManagerLibrary.Instance.ErasureMethodRegistrar[new Guid(param)]; 
     557                return Host.Instance.ErasureMethods[new Guid(param)]; 
    557558            } 
    558559            catch (FormatException) 
     
    560561                //Invalid GUID. Check every registered erasure method for the name 
    561562                string upperParam = param.ToUpperInvariant(); 
    562                 ErasureMethod result = null; 
    563                 foreach (ErasureMethod method in ManagerLibrary.Instance.ErasureMethodRegistrar) 
     563                IErasureMethod result = null; 
     564                foreach (IErasureMethod method in Host.Instance.ErasureMethods) 
    564565                { 
    565566                    if (method.Name.ToUpperInvariant() == upperParam) 
     
    595596        private static void CommandShell(ConsoleArguments args) 
    596597        { 
    597             switch (((ShellArguments)args).ShellAction) 
    598             { 
    599                 case ShellActions.SecureMove: 
    600                     CommandShellSecureMove((ShellArguments)args); 
    601                     break; 
    602  
    603                 default: 
    604                     CommandShellErase((ShellArguments)args); 
    605                     break; 
    606             } 
    607         } 
    608  
    609         /// <summary> 
    610         /// Handles the erasure of files from the Shell extension. 
    611         /// </summary> 
    612         /// <param name="args">The command line parameters passed to the program.</param> 
    613         private static void CommandShellErase(ShellArguments args) 
    614         { 
    615             //Construct a draft task. 
    616             Task task = new Task(); 
    617             switch (args.ShellAction) 
    618             { 
    619                 case ShellActions.EraseOnRestart: 
    620                     task.Schedule = Schedule.RunOnRestart; 
    621                     goto case ShellActions.EraseNow; 
    622  
    623                 case ShellActions.EraseNow: 
    624                     foreach (string path in args.PositionalArguments) 
    625                     { 
    626                         //If the path doesn't exist, skip the file 
    627                         if (!(File.Exists(path) || Directory.Exists(path))) 
    628                             continue; 
    629  
    630                         FileSystemObjectErasureTarget target = null; 
    631                         if ((File.GetAttributes(path) & FileAttributes.Directory) != 0) 
    632                         { 
    633                             target = new FolderErasureTarget(); 
    634                             target.Path = path; 
    635                         } 
    636                         else 
    637                         { 
    638                             target = new FileErasureTarget(); 
    639                             target.Path = path; 
    640                         } 
    641  
    642                         task.Targets.Add(target); 
    643                     } 
    644  
    645                     //Was the recycle bin specified? 
    646                     if (args.RecycleBin) 
    647                         task.Targets.Add(new RecycleBinErasureTarget()); 
    648                     break; 
    649  
    650                 case ShellActions.EraseUnusedSpace: 
    651                     foreach (string path in args.PositionalArguments) 
    652                     { 
    653                         UnusedSpaceErasureTarget target = new UnusedSpaceErasureTarget(); 
    654                         target.Drive = path; 
    655                         task.Targets.Add(target); 
    656                     } 
    657                     break; 
    658             } 
     598            ShellArguments arguments = (ShellArguments)args; 
     599            Task task = TaskFromCommandLine(arguments); 
    659600 
    660601            //Do we have a parent dialog? 
    661602            IWin32Window parent = null; 
    662             if (args.Parent != null) 
     603            if (arguments.Parent != null) 
    663604            { 
    664605                parent = new Win32Window((IntPtr)(ulong) 
    665                     Convert.ChangeType(args.Parent, typeof(ulong))); 
     606                    Convert.ChangeType(arguments.Parent, typeof(ulong))); 
    666607            } 
    667608 
    668609            //Confirm that the user wants the erase. 
    669             Application.EnableVisualStyles(); 
    670             using (Form dialog = new ShellConfirmationDialog(task)) 
    671             { 
    672                 if (dialog.ShowDialog(parent) != DialogResult.Yes) 
    673                     return; 
    674             } 
    675  
    676             //Then queue for erasure. 
    677             using (eraserClient = CommandConnect()) 
    678                 eraserClient.Tasks.Add(task); 
    679         } 
    680  
    681         /// <summary> 
    682         /// Handles the movement of files from the Shell extension. 
    683         /// </summary> 
    684         /// <param name="args">The command line parameters passed to the program.</param> 
    685         private static void CommandShellSecureMove(ShellArguments args) 
    686         { 
    687             //Construct a draft task. 
    688             Task task = new Task(); 
    689             foreach (string path in args.PositionalArguments) 
    690             { 
    691                 SecureMoveErasureTarget target = new SecureMoveErasureTarget(); 
    692                 target.Path = path; 
    693                 target.Destination = args.Destination; 
    694  
    695                 task.Targets.Add(target); 
     610            if (arguments.Confirm) 
     611            { 
     612                Application.EnableVisualStyles(); 
     613                using (Form dialog = new ShellConfirmationDialog(task)) 
     614                { 
     615                    if (dialog.ShowDialog(parent) != DialogResult.Yes) 
     616                        return; 
     617                } 
    696618            } 
    697619 
     
    852774        /// </summary> 
    853775        public const string SettingsPath = @"SOFTWARE\Eraser\Eraser 6"; 
     776 
     777        public static IEnumerable<IErasureTarget> ErasureTargetRegistrar { get; set; } 
    854778    } 
    855779 
  • trunk/eraser/Eraser/ProgressForm.Designer.cs

    r1675 r2509  
    5050        private void InitializeComponent() 
    5151        { 
     52            this.components = new System.ComponentModel.Container(); 
    5253            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ProgressForm)); 
    5354            this.overallProgressLbl = new System.Windows.Forms.Label(); 
     
    7071            this.timeLeft = new System.Windows.Forms.Label(); 
    7172            this.hide = new System.Windows.Forms.Button(); 
     73            this.progressTimer = new System.Windows.Forms.Timer(this.components); 
    7274            ((System.ComponentModel.ISupportInitialize)(this.title)).BeginInit(); 
    7375            this.SuspendLayout(); 
     
    179181            this.hide.UseVisualStyleBackColor = true; 
    180182            this.hide.Click += new System.EventHandler(this.hide_Click); 
     183            //  
     184            // progressTimer 
     185            //  
     186            this.progressTimer.Enabled = true; 
     187            this.progressTimer.Interval = 300; 
     188            this.progressTimer.Tick += new System.EventHandler(this.progressTimer_Tick); 
    181189            //  
    182190            // ProgressForm 
     
    236244        private System.Windows.Forms.Label timeLeft; 
    237245        private System.Windows.Forms.Button hide; 
     246        private System.Windows.Forms.Timer progressTimer; 
    238247    } 
    239248} 
  • trunk/eraser/Eraser/ProgressForm.cs

    r2203 r2509  
    2828 
    2929using Eraser.Manager; 
     30using Eraser.Plugins; 
     31using Eraser.Plugins.ExtensionPoints; 
    3032using Eraser.Util; 
    3133using System.Globalization; 
     
    4749 
    4850            //Register the event handlers 
    49             jobTitle.Text = task.UIText; 
    50             task.ProgressChanged += task_ProgressChanged; 
     51            jobTitle.Text = task.ToString(); 
    5152            task.TaskFinished += task_TaskFinished; 
    5253 
    5354            //Set the current progress 
    54             if (task.Progress.CurrentStep != null) 
    55                 UpdateProgress(task.Progress.CurrentStep.Progress, 
    56                     new ProgressChangedEventArgs(task.Progress.CurrentStep.Progress, null)); 
     55            UpdateProgress(); 
    5756        } 
    5857 
    5958        private void ProgressForm_FormClosed(object sender, FormClosedEventArgs e) 
    6059        { 
    61             task.ProgressChanged -= task_ProgressChanged; 
    6260            task.TaskFinished -= task_TaskFinished; 
    6361        } 
    6462 
    65         private void task_ProgressChanged(object sender, ProgressChangedEventArgs e) 
     63        private void progressTimer_Tick(object sender, EventArgs e) 
     64        { 
     65            UpdateProgress(); 
     66        } 
     67 
     68        private void task_TaskFinished(object sender, EventArgs e) 
    6669        { 
    6770            if (IsDisposed || !IsHandleCreated) 
     
    6972            if (InvokeRequired) 
    7073            { 
    71                 //Don't update too often - we can slow down the code. 
    72                 if (DateTime.Now - lastUpdate < new TimeSpan(0, 0, 0, 0, 300)) 
    73                     return; 
    74  
    75                 lastUpdate = DateTime.Now; 
    76                 Invoke((EventHandler<ProgressChangedEventArgs>)task_ProgressChanged, sender, e); 
    77                 return; 
    78             } 
    79  
    80             ErasureTarget target = sender as ErasureTarget; 
    81             if (target == null) 
    82                 return; 
    83  
    84             UpdateProgress(target.Progress, e); 
    85         } 
    86  
    87         private void task_TaskFinished(object sender, EventArgs e) 
    88         { 
    89             if (IsDisposed || !IsHandleCreated) 
    90                 return; 
    91             if (InvokeRequired) 
    92             { 
    9374                Invoke((EventHandler)task_TaskFinished, sender, e); 
    9475                return; 
    9576            } 
     77 
     78            //Stop the progress timer 
     79            progressTimer.Stop(); 
    9680 
    9781            //Update the UI. Set everything to 100% 
     
    140124        } 
    141125 
    142         private void UpdateProgress(ProgressManagerBase targetProgress, ProgressChangedEventArgs e) 
    143         { 
    144             TaskProgressChangedEventArgs e2 = (TaskProgressChangedEventArgs)e.UserState; 
    145             { 
    146                 SteppedProgressManager targetProgressStepped = 
    147                     targetProgress as SteppedProgressManager; 
    148                 if (targetProgressStepped != null && targetProgressStepped.CurrentStep != null) 
    149                     status.Text = targetProgressStepped.CurrentStep.Name; 
    150                 else 
    151                     status.Text = S._("Erasing..."); 
    152             } 
    153  
    154             if (e2 != null) 
    155             { 
    156                 item.Text = WrapItemName(e2.ItemName); 
    157                 pass.Text = e2.ItemTotalPasses != 0 ? 
    158                     S._("{0} out of {1}", e2.ItemPass, e2.ItemTotalPasses) : 
    159                     e2.ItemPass.ToString(CultureInfo.CurrentCulture); 
    160             } 
    161  
    162             if (targetProgress.TimeLeft >= TimeSpan.Zero) 
    163                 timeLeft.Text = S._("About {0} left", RoundToSeconds(targetProgress.TimeLeft)); 
     126        private void UpdateProgress() 
     127        { 
     128            if (!task.Executing) 
     129            { 
     130                //The task is done! Bail out and let the completion handler reset the UI 
     131                return; 
     132            } 
     133 
     134            //Get the name of the current erasure target to display the overall status 
     135            SteppedProgressManager taskProgress = task.Progress; 
     136            ErasureTargetProgressManagerStep taskStep = 
     137                (ErasureTargetProgressManagerStep)taskProgress.CurrentStep; 
     138            if (taskStep == null) 
     139                return; 
     140            else if (!string.IsNullOrEmpty(taskStep.Name)) 
     141                status.Text = taskStep.Name; 
     142            else 
     143                status.Text = S._("Erasing..."); 
     144 
     145            //The get the current step of the target to set the current item name 
     146            SteppedProgressManagerStepBase targetStep = 
     147                (SteppedProgressManagerStepBase)taskStep.Target.Progress.CurrentStep; 
     148            if (targetStep == null) 
     149                return; 
     150            else if (!string.IsNullOrEmpty(targetStep.Name)) 
     151                item.Text = WrapItemName(targetStep.Name); 
     152 
     153            //Determine if the tag information of the step's progress manager is an 
     154            //object array or a string. 
     155            ProgressManagerBase targetStepProgress = targetStep.Progress; 
     156            { 
     157                object tag = targetStepProgress.Tag; 
     158                if (tag == null) 
     159                { 
     160                    if (string.IsNullOrEmpty(targetStep.Name)) 
     161                        item.Text = string.Empty; 
     162                } 
     163                else if (tag.GetType() == typeof(string)) 
     164                    item.Text = (string)tag; 
     165                else if (tag.GetType() == typeof(int[])) 
     166                    pass.Text = S._("{0} out of {1}", ((int[])tag)[0], ((int[])tag)[1]); 
     167            } 
     168 
     169            if (targetStepProgress.TimeLeft >= TimeSpan.Zero) 
     170                timeLeft.Text = S._("About {0} left", RoundToSeconds(targetStepProgress.TimeLeft)); 
    164171            else 
    165172                timeLeft.Text = S._("Unknown"); 
    166173 
    167             if (!targetProgress.ProgressIndeterminate) 
     174            if (!targetStepProgress.ProgressIndeterminate) 
    168175            { 
    169176                itemProgress.Style = ProgressBarStyle.Continuous; 
    170                 itemProgress.Value = (int)(targetProgress.Progress * 1000); 
    171                 itemProgressLbl.Text = targetProgress.Progress.ToString("#0%", 
     177                itemProgress.Value = (int)(targetStepProgress.Progress * 1000); 
     178                itemProgressLbl.Text = targetStepProgress.Progress.ToString("#0%", 
    172179                    CultureInfo.CurrentCulture); 
    173180            } 
     
    178185            } 
    179186 
    180             if (!task.Progress.ProgressIndeterminate) 
     187            if (!taskProgress.ProgressIndeterminate) 
    181188            { 
    182189                overallProgress.Style = ProgressBarStyle.Continuous; 
    183                 overallProgress.Value = (int)(task.Progress.Progress * 1000); 
    184                 overallProgressLbl.Text = S._("Total: {0,2:#0.00%}", task.Progress.Progress); 
     190                overallProgress.Value = (int)(taskProgress.Progress * 1000); 
     191                overallProgressLbl.Text = S._("Total: {0,2:#0.00%}", taskProgress.Progress); 
    185192            } 
    186193            else 
  • trunk/eraser/Eraser/ProgressForm.resx

    r2220 r2509  
    113113  </resheader> 
    114114  <resheader name="reader"> 
    115     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     115    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    116116  </resheader> 
    117117  <resheader name="writer"> 
    118     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     118    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    119119  </resheader> 
    120   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" /> 
     120  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" /> 
    121121  <data name="overallProgressLbl.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms"> 
    122122    <value>Top, Bottom, Left, Right</value> 
    123123  </data> 
    124   <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" /> 
     124  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" /> 
    125125  <data name="overallProgressLbl.Location" type="System.Drawing.Point, System.Drawing"> 
    126126    <value>6, 174</value> 
     
    129129    <value>128, 15</value> 
    130130  </data> 
    131   <assembly alias="mscorlib" name="mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" /> 
     131  <assembly alias="mscorlib" name="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" /> 
    132132  <data name="overallProgressLbl.TabIndex" type="System.Int32, mscorlib"> 
    133133    <value>1</value> 
     
    143143  </data> 
    144144  <data name="&gt;&gt;overallProgressLbl.Type" xml:space="preserve"> 
    145     <value>System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     145    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    146146  </data> 
    147147  <data name="&gt;&gt;overallProgressLbl.Parent" xml:space="preserve"> 
     
    164164  </data> 
    165165  <data name="&gt;&gt;overallProgress.Type" xml:space="preserve"> 
    166     <value>System.Windows.Forms.ProgressBar, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     166    <value>System.Windows.Forms.ProgressBar, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    167167  </data> 
    168168  <data name="&gt;&gt;overallProgress.Parent" xml:space="preserve"> 
     
    191191  </data> 
    192192  <data name="&gt;&gt;jobTitle.Type" xml:space="preserve"> 
    193     <value>System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     193    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    194194  </data> 
    195195  <data name="&gt;&gt;jobTitle.Parent" xml:space="preserve"> 
     
    221221  </data> 
    222222  <data name="&gt;&gt;status.Type" xml:space="preserve"> 
    223     <value>System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     223    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    224224  </data> 
    225225  <data name="&gt;&gt;status.Parent" xml:space="preserve"> 
     
    248248  </data> 
    249249  <data name="&gt;&gt;statusLbl.Type" xml:space="preserve"> 
    250     <value>System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     250    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    251251  </data> 
    252252  <data name="&gt;&gt;statusLbl.Parent" xml:space="preserve"> 
     
    275275  </data> 
    276276  <data name="&gt;&gt;itemLbl.Type" xml:space="preserve"> 
    277     <value>System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     277    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    278278  </data> 
    279279  <data name="&gt;&gt;itemLbl.Parent" xml:space="preserve"> 
     
    299299  </data> 
    300300  <data name="&gt;&gt;item.Type" xml:space="preserve"> 
    301     <value>System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     301    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    302302  </data> 
    303303  <data name="&gt;&gt;item.Parent" xml:space="preserve"> 
     
    326326  </data> 
    327327  <data name="&gt;&gt;passLbl.Type" xml:space="preserve"> 
    328     <value>System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
     328    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> 
    329329  </data> 
    330330&nb