source: branches/eraser6/pluginsRewrite/Eraser.DefaultPlugins/CustomMethodEditorForm.cs @ 2464

Revision 2464, 11.3 KB checked in by lowjoel, 3 years ago (diff)

Further compile fixes.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
Line 
1/*
2 * $Id$
3 * Copyright 2008-2010 The Eraser Project
4 * Original Author: Joel Low <lowjoel@users.sourceforge.net>
5 * Modified By: Kasra Nassiri <cjax@users.sourceforge.net> @10-11-2008 04:18:04
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;
29using System.Globalization;
30
31using Eraser.Util;
32using Eraser.Plugins;
33using Eraser.Plugins.ExtensionPoints;
34
35namespace Eraser.DefaultPlugins
36{
37    internal partial class CustomMethodEditorForm : Form
38    {
39        public CustomMethodEditorForm()
40        {
41            InitializeComponent();
42            Theming.ApplyTheme(this);
43        }
44
45        /// <summary>
46        /// Sets or retrieves the CustomErasureMethod object with all the values
47        /// in the dialog.
48        /// </summary>
49        public CustomErasureMethod Method
50        {
51            get
52            {
53                if (method == null)
54                {
55                    method = new CustomErasureMethod();
56                    method.Guid = Guid.NewGuid();
57                }
58
59                //The method name.
60                method.Name = nameTxt.Text;
61
62                //Whether passes can be randomized when executing.
63                method.RandomizePasses = randomizeChk.Checked;
64
65                //And all the passes.
66                ErasureMethodPass[] passes = new ErasureMethodPass[passesLv.Items.Count];
67                for (int i = 0; i < passesLv.Items.Count; ++i)
68                    passes[i] = (ErasureMethodPass)passesLv.Items[i].Tag;
69                method.Passes = passes;
70
71                return method;
72            }
73            set
74            {
75                method = value;
76
77                //Method name.
78                nameTxt.Text = method.Name;
79
80                //Randomize passes
81                randomizeChk.Checked = method.RandomizePasses;
82
83                //Every pass.
84                foreach (ErasureMethodPass pass in method.Passes)
85                    AddPass(pass);
86            }
87        }
88
89        /// <summary>
90        /// Adds the given pass to the displayed list of passes.
91        /// </summary>
92        /// <param name="pass">The pass to add.</param>
93        /// <returns>The item added to the list view.</returns>
94        private ListViewItem AddPass(ErasureMethodPass pass)
95        {
96            ListViewItem item = new ListViewItem((passesLv.Items.Count + 1).ToString(
97                CultureInfo.CurrentCulture));
98            item.Tag = pass;
99            if (pass.Function == PassBasedErasureMethod.WriteRandom)
100                item.SubItems.Add(S._("Random Data"));
101            else
102                item.SubItems.Add(S._("Constant ({0} bytes)", ((byte[])pass.OpaqueValue).Length));
103
104            passesLv.Items.Add(item);
105            return item;
106        }
107
108        /// <summary>
109        /// Saves the currently edited pass details to memory.
110        /// </summary>
111        private void SavePass(ListViewItem item)
112        {
113            ErasureMethodPass pass = (ErasureMethodPass)item.Tag;
114            if (passEditor.PassType == CustomMethodPassEditorPassType.Random)
115            {
116                pass.Function = PassBasedErasureMethod.WriteRandom;
117                pass.OpaqueValue = null;
118                item.SubItems[1].Text = S._("Random Data");
119            }
120            else
121            {
122                pass.Function = PassBasedErasureMethod.WriteConstant;
123                pass.OpaqueValue = passEditor.PassData;
124                item.SubItems[1].Text = S._("Constant ({0} bytes)", passEditor.PassData.Length);
125            }
126        }
127
128        /// <summary>
129        /// Displays the pass associated with <paramref name="item"/> in the editing controls.
130        /// </summary>
131        /// <param name="item">The <see cref="ListViewItem"/> containing the pass to edit.</param>
132        private void DisplayPass(ListViewItem item)
133        {
134            currentPass = item;
135            ErasureMethodPass pass = (ErasureMethodPass)item.Tag;
136            passEditor.PassData = (byte[])pass.OpaqueValue;
137            passEditor.PassType = pass.Function == PassBasedErasureMethod.WriteRandom ?
138                CustomMethodPassEditorPassType.Random :
139                CustomMethodPassEditorPassType.Text;
140        }
141
142        /// <summary>
143        /// Renumbers all pass entries' pass number to be in sync with its position.
144        /// </summary>
145        private void RenumberPasses()
146        {
147            foreach (ListViewItem item in passesLv.Items)
148                item.Text = (item.Index + 1).ToString(CultureInfo.CurrentCulture);
149        }
150
151        /// <summary>
152        /// Enables buttons relevant to the currently selected items.
153        /// </summary>
154        private void EnableButtons()
155        {
156            passesRemoveBtn.Enabled = passesDuplicateBtn.Enabled = passesLv.SelectedItems.Count >= 1;
157            passGrp.Enabled = passEditor.Enabled = passesLv.SelectedItems.Count == 1;
158        }
159
160        private void passesAddBtn_Click(object sender, EventArgs e)
161        {
162            //Save the current pass being edited
163            if (currentPass != null)
164                SavePass(currentPass);
165
166            //Then create a new, random pass, adding it to the list
167            ErasureMethodPass pass = new ErasureMethodPass(PassBasedErasureMethod.WriteRandom, null);
168            ListViewItem item = AddPass(pass);
169
170            //If a pass is currently selected, insert the pass after the currently selected one.
171            if (passesLv.SelectedIndices.Count > 0)
172            {
173                item.Remove();
174                passesLv.Items.Insert(passesLv.SelectedIndices[passesLv.SelectedIndices.Count - 1] + 1,
175                    item);
176                RenumberPasses();
177            }
178        }
179
180        private void passesRemoveBtn_Click(object sender, EventArgs e)
181        {
182            foreach (ListViewItem item in passesLv.SelectedItems)
183                passesLv.Items.Remove(item);
184
185            RenumberPasses();
186        }
187
188        private void passesDuplicateBtn_Click(object sender, EventArgs e)
189        {
190            //Save the current pass to prevent data loss
191            SavePass(currentPass);
192
193            foreach (ListViewItem item in passesLv.SelectedItems)
194            {
195                ErasureMethodPass oldPass = (ErasureMethodPass)item.Tag;
196                ErasureMethodPass pass = new ErasureMethodPass(
197                    oldPass.Function, oldPass.OpaqueValue);
198                AddPass(pass);
199            }
200        }
201
202        private void passesLv_ItemDrag(object sender, ItemDragEventArgs e)
203        {
204            //Save the currently edited pass before allowing the drag & drop operation.
205            SavePass(currentPass);
206
207            //Then initiate the drag & drop.
208            passesLv.DoDragDrop(passesLv.SelectedItems, DragDropEffects.All);
209        }
210
211        private void passesLv_DragEnter(object sender, DragEventArgs e)
212        {
213            ListView.SelectedListViewItemCollection items =
214                e.Data.GetData(typeof(ListView.SelectedListViewItemCollection)) as
215                    ListView.SelectedListViewItemCollection;
216            if (items == null)
217                return;
218
219            e.Effect = DragDropEffects.Move;
220        }
221
222        ListViewItem lastInsertionPoint;
223        private void passesLv_GiveFeedback(object sender, GiveFeedbackEventArgs e)
224        {
225            e.UseDefaultCursors = true;
226            Point mousePoint = passesLv.PointToClient(Cursor.Position);
227            ListViewItem insertionPoint = GetInsertionPoint(mousePoint);
228
229            if (insertionPoint != lastInsertionPoint)
230            {
231                passesLv.Invalidate();
232                passesLv.Update();
233
234                using (Graphics g = passesLv.CreateGraphics())
235                {
236                    //Only handle the exception: when insertionPoint is null, the item should
237                    //be appended to the back of the listview.
238                    if (insertionPoint == null)
239                    {
240                        if (passesLv.Items.Count > 0)
241                        {
242                            ListViewItem lastItem = passesLv.Items[passesLv.Items.Count - 1];
243                            g.FillRectangle(new SolidBrush(Color.Black),
244                                lastItem.Bounds.Left, lastItem.Bounds.Bottom - 1, passesLv.Width, 2);
245                        }
246                        else
247                        {
248                            g.FillRectangle(new SolidBrush(Color.Black),
249                                   0, 0, passesLv.Width, 2);
250                        }
251                    }
252                    else
253                    {
254                        g.FillRectangle(new SolidBrush(Color.Black),
255                            insertionPoint.Bounds.Left, insertionPoint.Bounds.Top - 1, passesLv.Width, 2);
256                    }
257                }
258
259                lastInsertionPoint = insertionPoint;
260            }
261        }
262
263        private void passesLv_DragDrop(object sender, DragEventArgs e)
264        {
265            //Remove the insertion mark
266            lastInsertionPoint = null;
267
268            //Get the item we dragged and the item we dropped over.
269            ListView.SelectedListViewItemCollection draggedItems =
270                e.Data.GetData(typeof(ListView.SelectedListViewItemCollection)) as
271                    ListView.SelectedListViewItemCollection;
272            List<ListViewItem> items = new List<ListViewItem>(draggedItems.Count);
273            foreach (ListViewItem item in draggedItems)
274                items.Add(item);
275            Point mousePoint = passesLv.PointToClient(Cursor.Position);
276            ListViewItem dropItem = GetInsertionPoint(mousePoint);
277
278            //If we do not have an item, it is not a valid drag & drop operation.
279            if (items == null || items.Count == 0)
280                return;
281
282            //Ignore the operation if the drag source and the destination items match.
283            if (items.IndexOf(dropItem) != -1)
284                return;
285
286            //Prevent the listview from refreshing to speed things up.
287            passesLv.BeginUpdate();
288            passesLv.Invalidate();
289
290            //Remove the item we dragged
291            foreach (ListViewItem item in items)
292                item.Remove();
293
294            //If we don't have an item we dropped over, it's the last item in the list.
295            if (dropItem == null)
296            {
297                foreach (ListViewItem item in items)
298                    passesLv.Items.Add(item);
299            }
300            else
301            {
302                foreach (ListViewItem item in items)
303                    passesLv.Items.Insert(dropItem.Index, item);
304            }
305
306            //Renumber the passes for congruency
307            RenumberPasses();
308            EnableButtons();
309            passesLv.EndUpdate();
310        }
311
312        private void passesLv_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
313        {
314            EnableButtons();
315
316            //Determine if we should load or save the pass information
317            if (!e.Item.Selected)
318            {
319                if (e.Item == currentPass)
320                {
321                    SavePass(e.Item);
322                    currentPass = null;
323                }
324            }
325            else if (passesLv.SelectedIndices.Count == 1)
326            {
327                DisplayPass(passesLv.SelectedItems[0]);
328            }
329        }
330
331        /// <summary>
332        /// Calculates the item to insert the new dragged item before, based on
333        /// mouse coordinates.
334        /// </summary>
335        /// <param name="point">The current location of the cursor.</param>
336        /// <returns>The item to insert the new item before, or null if the item
337        /// should be appended to the list.</returns>
338        private ListViewItem GetInsertionPoint(Point point)
339        {
340            ListViewItem item = passesLv.GetItemAt(0, point.Y);
341            if (item == null)
342                return null;
343
344            bool beforeItem = point.Y < item.Bounds.Height / 2 + item.Bounds.Y;
345            if (beforeItem)
346            {
347                return item;
348            }
349            else if (item.Index == passesLv.Items.Count - 1)
350            {
351                return null;
352            }
353            else
354            {
355                return passesLv.Items[item.Index + 1];
356            }
357        }
358
359        private void okBtn_Click(object sender, EventArgs e)
360        {
361            //Clear the errorProvider status
362            errorProvider.Clear();
363            bool hasError = false;
364
365            //Save the currently edited pass.
366            if (passesLv.SelectedItems.Count == 1)
367                SavePass(passesLv.SelectedItems[0]);
368
369            //Validate the information
370            if (nameTxt.Text.Length == 0)
371            {
372                errorProvider.SetError(nameTxt, S._("The name of the custom method cannot be empty."));
373                errorProvider.SetIconPadding(nameTxt, -16);
374                hasError = true;
375            }
376
377            //Validate all passes
378            if (passesLv.Items.Count == 0)
379            {
380                errorProvider.SetError(passesLv, S._("The method needs to have at least one pass " +
381                    "defined."));
382                errorProvider.SetIconPadding(passesLv, -16);
383                hasError = true;
384            }
385
386            //If there are errors, don't close the dialog.
387            if (!hasError)
388            {
389                DialogResult = DialogResult.OK;
390                Close();
391            }
392        }
393
394        /// <summary>
395        /// Holds the CustomErasureMethod object which client code may set to allow
396        /// method editing.
397        /// </summary>
398        private CustomErasureMethod method;
399
400        /// <summary>
401        /// Holds the current Erasure pass that is being edited.
402        /// </summary>
403        private ListViewItem currentPass;
404    }
405}
Note: See TracBrowser for help on using the repository browser.