Changeset 2015

Timestamp:

5/2/2010 10:51:06 AM (3 years ago)

Author:

lowjoel

Message:

Implemented a confirmation dialog before erasures are processed. Fixes #340.

Location:

trunk/eraser

Files:

• Eraser.Shell/CtxMenu.cpp (modified) (8 diffs)
• Eraser.Shell/CtxMenu.h (modified) (2 diffs)
• Eraser/Eraser.csproj (modified) (2 diffs)
• Eraser/Program.cs (modified) (5 diffs)
• Eraser/ShellConfirmationDialog.Designer.cs (added)
• Eraser/ShellConfirmationDialog.cs (added)
• Eraser/ShellConfirmationDialog.resx (added)

trunk/eraser/Eraser.Shell/CtxMenu.cpp

@@ -491 +491 @@
 
         //Build the command line
-        std::wstring commandAction;
         std::wstring commandLine;
         bool commandElevate = false;
-        HRESULT result = E_INVALIDARG;
         switch (VerbMenuIndices[LOWORD(pCmdInfo->lpVerb)])
         {
         case ACTION_ERASE_ON_RESTART:
-            commandLine += L"/schedule=restart ";
-
         case ACTION_ERASE:
-            {
-                //Add Task command.
-                commandAction = L"addtask";
-
-                //See the invocation context: if it is executed from the recycle bin
-                //then the list of selected files will be empty.
-                if (InvokeReason == INVOKEREASON_RECYCLEBIN)
-                {
-                    commandLine += L"recyclebin";
-                }
-                else
-                {
-                    //Okay, we were called from an item right-click; iterate over every
-                    //selected file
-                    for (std::list<std::wstring>::const_iterator i = SelectedFiles.begin();
-                        i != SelectedFiles.end(); ++i)
-                    {
-                        //Check if the current item is a file or folder.
-                        std::wstring item(*i);
-                        if (item.length() > 2 && item[item.length() - 1] == '\\')
-                            item.erase(item.end() - 1);
-                        DWORD attributes = GetFileAttributes(item.c_str());
-
-                        //Add the correct command line for the file type.
-                        if (attributes & FILE_ATTRIBUTE_DIRECTORY)
-                            commandLine += L"\"dir=" + item + L"\" ";
-                        else
-                            commandLine += L"\"file=" + item + L"\" ";
-                    }
-                }
-
-                break;
-            }
+            //See the invocation context: if it is executed from the recycle bin
+            //then the list of selected files will be empty.
+            if (InvokeReason == INVOKEREASON_RECYCLEBIN)
+            {
+                commandLine += L"/recyclebin";
+            }
+
+            break;
 
         case ACTION_ERASE_UNUSED_SPACE:
-            {
-                //We want to add a new task
-                commandAction = L"addtask";
-
-                //Erasing unused space requires elevation
-                commandElevate = true;
-
-                //Add every item onto the command line
-                for (std::list<std::wstring>::const_iterator i = SelectedFiles.begin();
-                    i != SelectedFiles.end(); ++i)
-                {
-                    commandLine += L"\"unused=" + *i + L",clusterTips\" ";
-                }
-                
-                break;
-            }
+            //Erasing unused space requires elevation
+            commandElevate = true;
+            break;
 
         default:
@@ -559 +517 @@
                     VerbMenuIndices[LOWORD(pCmdInfo->lpVerb)]).c_str(),
                     LoadString(IDS_ERASERSHELLEXT).c_str(), MB_OK | MB_ICONERROR);
-            }
+                return E_INVALIDARG;
+            }
+        }
+
+        //Add the list of items selected.
+        for (std::list<std::wstring>::const_iterator i = SelectedFiles.begin();
+            i != SelectedFiles.end(); ++i)
+        {
+            commandLine += L"\"" + *i + L"\" ";
         }
 
@@ -565 +531 @@
         {
             BusyCursor cursor;
-            RunEraser(commandAction, commandLine, commandElevate, pCmdInfo->hwnd,
-                pCmdInfo->nShow);
+            RunEraser(VerbMenuIndices[LOWORD(pCmdInfo->lpVerb)], commandLine, commandElevate,
+                pCmdInfo->hwnd, pCmdInfo->nShow);
         }
         catch (const std::wstring& e)
@@ -577 +543 @@
         }
 
-        return result;
+        return S_OK;
     }
 
@@ -812 +778 @@
     }
 
-    void CCtxMenu::RunEraser(const std::wstring& action, const std::wstring& parameters,
-        bool elevated, HWND parent, int show)
+    void CCtxMenu::RunEraser(Actions action, const std::wstring& parameters, bool elevated,
+        HWND parent, int show)
     {
         //Get the path to this DLL so we can look for Eraser.exe
@@ -834 +800 @@
         eraserPath += L"Eraser.exe";
 
-        std::wstring finalParameters;
+        //Compile the final set of parameters we are going to pass to Eraser.
+        std::wstring finalParameters(L"shell /quiet ");
+
+        //Set the action selected by the user.
+        switch (action)
+        {
+        case ACTION_ERASE:
+            finalParameters += L"/action=EraseNow ";
+            break;
+        case ACTION_ERASE_ON_RESTART:
+            finalParameters += L"/action=EraseOnRestart ";
+            break;
+        case ACTION_ERASE_UNUSED_SPACE:
+            finalParameters += L"/action=EraseUnusedSpace ";
+            break;
+        default:
+            return;
+        }
+
+        //Then append the rest of the arguments, depending on the length.
         {
             //Depending on the length of the argument, we either use a response file
@@ -851 +836 @@
 
                 std::wofstream stream(buffer);
-                stream << "\"" << action << L"\" /quiet " << parameters;
-
-                finalParameters = L"\"@";
+                stream << parameters;
+
+                finalParameters += L"\"@";
                 finalParameters += buffer;
                 finalParameters += '"';
@@ -860 +845 @@
             {
                 //Short command line, pass directly to the program
-                std::wostringstream stream;
-                stream << "\"" << action << L"\" /quiet " << parameters;
-                finalParameters = stream.str();
+                finalParameters += parameters;
             }
         }

trunk/eraser/Eraser.Shell/CtxMenu.h

@@ -54 +54 @@
         };
 
+        /// This has the equivalent in Eraser.Program.ShellActions
         enum Actions
         {
@@ -86 +87 @@
 
         static bool IsUserAdmin();
-        static void RunEraser(const std::wstring& action, const std::wstring& parameters,
+        static void RunEraser(Actions action, const std::wstring& parameters,
             bool elevated, HWND parent, int show);
 

trunk/eraser/Eraser/Eraser.csproj

@@ -212 +212 @@
       <DependentUpon>SettingsPanel.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="ShellConfirmationDialog.resx">
+      <DependentUpon>ShellConfirmationDialog.cs</DependentUpon>
+    </EmbeddedResource>
     <EmbeddedResource Include="Strings.en.resx">
       <SubType>Designer</SubType>
@@ -333 +336 @@
   <ItemGroup>
     <Compile Include="Program.ConsoleProgram.cs" />
+    <Compile Include="ShellConfirmationDialog.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="ShellConfirmationDialog.Designer.cs">
+      <DependentUpon>ShellConfirmationDialog.cs</DependentUpon>
+    </Compile>
     <None Include="Resources\AboutDialog.png" />
     <CodeAnalysisDictionary Include="..\CustomDictionary.xml">

trunk/eraser/Eraser/Program.cs

@@ -101 +101 @@
         }
 
+        class ShellArguments : ConsoleArguments
+        {
+            /// <summary>
+            /// The action which the shell extension has requested.
+            /// </summary>
+            [Arg("action", "The action selected by the user", typeof(string), true, null, null)]
+            public ShellActions ShellAction { get; set; }
+
+            /// <summary>
+            /// Whether the recycle bin was specified on the command line.
+            /// </summary>
+            [Arg("recycleBin", "The recycle bin as an erasure target", typeof(string), false, null, null)]
+            public bool RecycleBin { get; set; }
+        }
+
+        public enum ShellActions
+        {
+            /// <summary>
+            /// Erase the selected items now.
+            /// </summary>
+            EraseNow,
+
+            /// <summary>
+            /// Erase the selected items on restart.
+            /// </summary>
+            EraseOnRestart,
+
+            /// <summary>
+            /// Erase the unused space on the drive.
+            /// </summary>
+            EraseUnusedSpace
+        }
+
         /// <summary>
         /// The main entry point for the application.
@@ -154 +187 @@
         #region Console Program code
         /// <summary>
+        /// Connects to the running Eraser instance for erasures.
+        /// </summary>
+        /// <returns>The connectin with the remote instance.</returns>
+        private static RemoteExecutorClient CommandConnect()
+        {
+            try
+            {
+                RemoteExecutorClient result = new RemoteExecutorClient();
+                result.Run();
+                if (!result.IsConnected)
+                {
+                    //The client cannot connect to the server. This probably means
+                    //that the server process isn't running. Start an instance.
+                    Process eraserInstance = Process.Start(
+                        Assembly.GetExecutingAssembly().Location, "/quiet");
+                    Thread.Sleep(0);
+                    eraserInstance.WaitForInputIdle();
+
+                    result.Run();
+                    if (!result.IsConnected)
+                        throw new IOException("Eraser cannot connect to the running " +
+                            "instance for erasures.");
+                }
+
+                return result;
+            }
+            catch (UnauthorizedAccessException e)
+            {
+                //We can't connect to the pipe because the other instance of Eraser
+                //is running with higher privileges than this instance.
+                throw new UnauthorizedAccessException("Another instance of Eraser " +
+                    "is already running but it is running with higher privileges than " +
+                    "this instance of Eraser. Tasks cannot be added in this manner.\n\n" +
+                    "Close the running instance of Eraser and start it again without " +
+                    "administrator privileges, or run the command again as an " +
+                    "administrator.", e);
+            }
+        }
+
+        /// <summary>
         /// Runs Eraser as a command-line application.
         /// </summary>
@@ -171 +244 @@
                     program.Handlers.Add("importtasklist",
                         new ConsoleActionData(CommandImportTaskList, new ConsoleArguments()));
+                    program.Handlers.Add("shell",
+                        new ConsoleActionData(CommandShell, new ShellArguments()));
                     program.Run();
                     return 0;
@@ -408 +483 @@
 
             //Send the task out.
-            try
-            {
-                using (RemoteExecutorClient client = new RemoteExecutorClient())
-                {
-                    client.Run();
-                    if (!client.IsConnected)
-                    {
-                        //The client cannot connect to the server. This probably means
-                        //that the server process isn't running. Start an instance.
-                        Process eraserInstance = Process.Start(
-                            Assembly.GetExecutingAssembly().Location, "/quiet");
-                        Thread.Sleep(0);
-                        eraserInstance.WaitForInputIdle();
-
-                        client.Run();
-                        if (!client.IsConnected)
-                            throw new IOException("Eraser cannot connect to the running " +
-                                "instance for erasures.");
-                    }
-
-                    client.Tasks.Add(task);
-                }
-            }
-            catch (UnauthorizedAccessException e)
-            {
-                //We can't connect to the pipe because the other instance of Eraser
-                //is running with higher privileges than this instance.
-                throw new UnauthorizedAccessException("Another instance of Eraser " +
-                    "is already running but it is running with higher privileges than " +
-                    "this instance of Eraser. Tasks cannot be added in this manner.\n\n" +
-                    "Close the running instance of Eraser and start it again without " +
-                    "administrator privileges, or run the command again as an " +
-                    "administrator.", e);
-            }
+            using (eraserClient = CommandConnect())
+                eraserClient.Tasks.Add(task);
         }
 
@@ -451 +494 @@
         {
             //Import the task list
-            try
-            {
-                using (RemoteExecutorClient client = new RemoteExecutorClient())
-                {
-                    client.Run();
-                    if (!client.IsConnected)
+            using (eraserClient = CommandConnect())
+                foreach (string path in args.PositionalArguments)
+                    using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
+                        eraserClient.Tasks.LoadFromStream(stream);
+        }
+
+        /// <summary>
+        /// Handles the files from the Shell extension.
+        /// </summary>
+        /// <param name="args">The command line parameters passed to the program.</param>
+        private static void CommandShell(ConsoleArguments args)
+        {
+            //Construct a draft task.
+            Task task = new Task();
+            switch (((ShellArguments)args).ShellAction)
+            {
+                case ShellActions.EraseOnRestart:
+                    task.Schedule = Schedule.RunOnRestart;
+                    goto case ShellActions.EraseNow;
+
+                case ShellActions.EraseNow:
+                    foreach (string path in args.PositionalArguments)
                     {
-                        //The client cannot connect to the server. This probably means
-                        //that the server process isn't running. Start an instance.
-                        Process eraserInstance = Process.Start(
-                            Assembly.GetExecutingAssembly().Location, "/quiet");
-                        eraserInstance.WaitForInputIdle();
-
-                        client.Run();
-                        if (!client.IsConnected)
-                            throw new IOException("Eraser cannot connect to the running " +
-                                "instance for erasures.");
+                        FileSystemObjectTarget target = null;
+                        if (Directory.Exists(path))
+                        {
+                            target = new FolderTarget();
+                            target.Path = path;
+                        } 
+                        else
+                        {
+                            target = new FileTarget();
+                            target.Path = path;
+                        }
+
+                        task.Targets.Add(target);
                     }
 
+                    //Was the recycle bin specified?
+                    if (((ShellArguments)args).RecycleBin)
+                        task.Targets.Add(new RecycleBinTarget());
+                    break;
+
+                case ShellActions.EraseUnusedSpace:
                     foreach (string path in args.PositionalArguments)
-                        using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
-                            client.Tasks.LoadFromStream(stream);
-                }
-            }
-            catch (UnauthorizedAccessException e)
-            {
-                //We can't connect to the pipe because the other instance of Eraser
-                //is running with higher privileges than this instance.
-                throw new UnauthorizedAccessException("Another instance of Eraser " +
-                    "is already running but it is running with higher privileges than " +
-                    "this instance of Eraser. Tasks cannot be added in this manner.\n\n" +
-                    "Close the running instance of Eraser and start it again without " +
-                    "administrator privileges, or run the command again as an " +
-                    "administrator.", e);
-            }
+                    {
+                        UnusedSpaceTarget target = new UnusedSpaceTarget();
+                        target.Drive = path;
+                        task.Targets.Add(target);
+                    }
+                    break;
+            }
+
+            //Confirm that the user wants the erase.
+            Application.EnableVisualStyles();
+            using (Form dialog = new ShellConfirmationDialog(task))
+            {
+                if (dialog.ShowDialog() != DialogResult.Yes)
+                    return;
+            }
+
+            //Then queue for erasure.
+            using (eraserClient = CommandConnect())
+                eraserClient.Tasks.Add(task);
         }
         #endregion