source: branches/eraser6/Eraser/TaskDataSelectionForm.cs @ 903

Revision 903, 8.0 KB checked in by lowjoel, 6 years ago (diff)

Ran Static code analysis on the Eraser project and implemented a few recommendations.

-Use more specific exceptions to allow code to determine the type of exception.
-Made GUIProgram implement IDisposable since the global mutex must be freed.
-Mde AboutForm? implement IDisposable, clearing the caching bitmaps on dispose.
-Made a few CommandLineProgram? functions static since they don't reference this.
-Name parameters/local with more unique, descriptive names for clarity.
-Use EventHandler?<EventArg?> instead of declaring our own delegate and event types as the type of the evenr handler

  • Property svn:keywords set to Id
Line 
1/*
2 * $Id$
3 * Copyright 2008 The Eraser Project
4 * Original Author: Joel Low <lowjoel@users.sourceforge.net>
5 * Modified By:
6 *
7 * This file is part of Eraser.
8 *
9 * Eraser is free software: you can redistribute it and/or modify it under the
10 * terms of the GNU General Public License as published by the Free Software
11 * Foundation, either version 3 of the License, or (at your option) any later
12 * version.
13 *
14 * Eraser is distributed in the hope that it will be useful, but WITHOUT ANY
15 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
16 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
17 *
18 * A copy of the GNU General Public License can be found at
19 * <http://www.gnu.org/licenses/>.
20 */
21
22using System;
23using System.Collections.Generic;
24using System.ComponentModel;
25using System.Data;
26using System.Drawing;
27using System.Text;
28using System.Windows.Forms;
29
30using Eraser.Manager;
31using Eraser.Util;
32using System.IO;
33
34namespace Eraser
35{
36    public partial class TaskDataSelectionForm : Form
37    {
38        private class DriveItem
39        {
40            public override string ToString()
41            {
42                return Label;
43            }
44
45            public string Drive;
46            public string Label;
47            public Icon Icon;
48        }
49
50        public TaskDataSelectionForm()
51        {
52            //Create the UI
53            InitializeComponent();
54            file.Checked = true;
55
56            //Populate the drives list
57            List<VolumeInfo> volumes = VolumeInfo.GetVolumes();
58            foreach (VolumeInfo volume in volumes)
59            {
60                DriveType driveType = volume.VolumeType;
61                if (driveType != DriveType.Unknown &&
62                    driveType != DriveType.NoRootDirectory &&
63                    driveType != DriveType.CDRom &&
64                    driveType != DriveType.Network)
65                {
66                    //Skip drives which are not mounted: we cannot erase their unused space.
67                    if (volume.MountPoints.Count == 0)
68                        continue;
69
70                    DriveItem item = new DriveItem();
71                    string volumePath = volume.IsMounted ?
72                        volume.MountPoints[0] : volume.VolumeID;
73                    item.Drive = volumePath;
74                    item.Label = Eraser.Util.File.GetFileDescription(volumePath);
75                    item.Icon = Eraser.Util.File.GetFileIcon(volumePath);
76                    unusedDisk.Items.Add(item);
77                }
78            }
79
80            if (unusedDisk.Items.Count != 0)
81                unusedDisk.SelectedIndex = 0;
82
83            //And the methods list
84            Dictionary<Guid, ErasureMethod> methods = ErasureMethodManager.GetAll();
85            this.method.Items.Add(ErasureMethodManager.Default);
86            foreach (ErasureMethod method in methods.Values)
87                this.method.Items.Add(method);
88            if (this.method.Items.Count != 0)
89                this.method.SelectedIndex = 0;
90        }
91
92        /// <summary>
93        /// Retrieves the settings on the property page as the Eraser Manager API equivalent.
94        /// </summary>
95        /// <returns>An Eraser.Manager.Task.Data or Eraser.Manager.Task.UnusedSpace object
96        /// or any of its inherited classes, depending on the task selected</returns>
97        public Task.ErasureTarget Target
98        {
99            get
100            {
101                Task.ErasureTarget result = null;
102                if (file.Checked)
103                {
104                    Manager.Task.File fileTask = new Task.File();
105                    result = fileTask;
106
107                    fileTask.Path = filePath.Text;
108                }
109                else if (folder.Checked)
110                {
111                    Manager.Task.Folder folderTask = new Task.Folder();
112                    result = folderTask;
113
114                    folderTask.Path = folderPath.Text;
115                    folderTask.IncludeMask = folderInclude.Text;
116                    folderTask.ExcludeMask = folderExclude.Text;
117                    folderTask.DeleteIfEmpty = folderDelete.Checked;
118                }
119                else if (unused.Checked)
120                {
121                    Task.UnusedSpace unusedSpaceTask = new Task.UnusedSpace();
122                    result = unusedSpaceTask;
123
124                    unusedSpaceTask.Drive = ((DriveItem)unusedDisk.SelectedItem).Drive;
125                    unusedSpaceTask.EraseClusterTips = unusedClusterTips.Checked;
126                }
127                else
128                {
129                    Task.RecycleBin recycleBinTask = new Task.RecycleBin();
130                    result = recycleBinTask;
131                }
132
133                result.Method = (ErasureMethod)this.method.SelectedItem;
134                return result;
135            }
136            set
137            {
138                //Set the erasure method.
139                if (value.MethodDefined)
140                {
141                    foreach (object item in method.Items)
142                        if (((ErasureMethod)item).GUID == value.Method.GUID)
143                            method.SelectedItem = item;
144                }
145                else
146                    method.SelectedIndex = 0;
147
148                //Then the data to be erased.
149                if (value is Task.File)
150                {
151                    file.Checked = true;
152                    filePath.Text = ((Task.File)value).Path;
153                }
154                else if (value is Task.Folder)
155                {
156                    folder.Checked = true;
157                    Manager.Task.Folder folderTask = (Task.Folder)value;
158
159                    folderPath.Text = folderTask.Path;
160                    folderInclude.Text = folderTask.IncludeMask;
161                    folderExclude.Text = folderTask.ExcludeMask;
162                    folderDelete.Checked = folderTask.DeleteIfEmpty;
163                }
164                else if (value is Task.UnusedSpace)
165                {
166                    unused.Checked = true;
167                    Task.UnusedSpace unusedSpaceTask = (Task.UnusedSpace)value;
168                    foreach (object item in unusedDisk.Items)
169                        if (((DriveItem)item).Drive == unusedSpaceTask.Drive)
170                            unusedDisk.SelectedItem = item;
171                    unusedClusterTips.Checked = unusedSpaceTask.EraseClusterTips;
172                }
173                else if (value is Task.RecycleBin)
174                {
175                    recycleBin.Checked = true;
176                }
177                else
178                    throw new ArgumentException("Unknown erasure target.");
179            }
180        }
181
182        private void method_SelectedIndexChanged(object sender, EventArgs e)
183        {
184            if (!(method.SelectedItem is UnusedSpaceErasureMethod) &&
185                method.SelectedItem != ErasureMethodManager.Default)
186            {
187                if (unused.Checked)
188                {
189                    file.Checked = true;
190                    errorProvider.SetError(unused, S._("The erasure method selected does " +
191                        "not support unused disk space erasures."));
192                }
193                unused.Enabled = false;
194            }
195            else if (!unused.Enabled)
196            {
197                unused.Enabled = true;
198                errorProvider.Clear();
199            }
200        }
201
202        private void data_CheckedChanged(object sender, EventArgs e)
203        {
204            filePath.Enabled = fileBrowse.Enabled = file.Checked;
205            folderPath.Enabled = folderBrowse.Enabled = folderIncludeLbl.Enabled =
206                folderInclude.Enabled = folderExcludeLbl.Enabled = folderExclude.Enabled =
207                folderDelete.Enabled = folder.Checked;
208            unusedDisk.Enabled = unusedClusterTips.Enabled = unused.Checked;
209            errorProvider.Clear();
210        }
211
212        private void fileBrowse_Click(object sender, EventArgs e)
213        {
214            fileDialog.FileName = filePath.Text;
215            if (fileDialog.ShowDialog() == DialogResult.OK)
216                filePath.Text = fileDialog.FileName;
217        }
218
219        private void folderBrowse_Click(object sender, EventArgs e)
220        {
221            try
222            {
223                folderDialog.SelectedPath = folderPath.Text;
224                if (folderDialog.ShowDialog() == DialogResult.OK)
225                    folderPath.Text = folderDialog.SelectedPath;
226            }
227            catch (NotSupportedException)
228            {
229                MessageBox.Show(this, S._("The path you selected is invalid."), S._("Eraser"),
230                    MessageBoxButtons.OK, MessageBoxIcon.Error);
231            }
232        }
233
234        private void unusedDisk_DrawItem(object sender, DrawItemEventArgs e)
235        {
236            if (e.Index == -1)
237                return;
238
239            Graphics g = e.Graphics;
240            DriveItem item = (DriveItem)unusedDisk.Items[e.Index];
241            Color textColour = e.ForeColor;
242            PointF textPos = e.Bounds.Location;
243            textPos.X += item.Icon.Width + 4;
244            textPos.Y += 2;
245
246            //Set the text colour and background colour if the control is disabled
247            if ((e.State & DrawItemState.Disabled) == 0)
248                e.DrawBackground();
249            else
250            {
251                g.FillRectangle(new SolidBrush(SystemColors.ButtonFace), e.Bounds);
252                textColour = SystemColors.GrayText;
253            }
254
255            g.DrawIcon(item.Icon, e.Bounds.X + 2, e.Bounds.Y);
256            g.DrawString(item.Label, e.Font, new SolidBrush(textColour), textPos);
257            if ((e.State & DrawItemState.Focus) != 0)
258                e.DrawFocusRectangle();
259        }
260
261        private void ok_Click(object sender, EventArgs e)
262        {
263            if (file.Checked && filePath.Text.Length == 0)
264                errorProvider.SetError(filePath, S._("Invalid file path"));
265            else if (folder.Checked && folderPath.Text.Length == 0)
266                errorProvider.SetError(folderPath, S._("Invalid folder path"));
267            else
268            {
269                errorProvider.Clear();
270                DialogResult = DialogResult.OK;
271                Close();
272            }
273        }
274    }
275}
Note: See TracBrowser for help on using the repository browser.