Ignore:
Timestamp:
11/19/2008 1:44:01 AM (6 years ago)
Author:
lowjoel
Message:

Fully implemented the Custom method editor and its associated error handling code

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/DefaultPlugins/CustomMethodEditorForm.cs

    r522 r585  
    4040 
    4141        /// <summary> 
    42         /// Holds the CustomErasureMethod object which client code may set to allow 
    43         /// method editing. 
    44         /// </summary> 
    45         private CustomErasureMethod method; 
    46  
    47         /// <summary> 
    4842        /// Sets or retrieves the CustomErasureMethod object with all the values 
    4943        /// in the dialog. 
     
    113107        { 
    114108            ErasureMethod.Pass pass = (ErasureMethod.Pass)item.Tag; 
    115             if (passTypeRandom.Checked) 
     109            if (passEditor.PassType == CustomMethodPassEditor.PassTypes.RANDOM) 
    116110            { 
    117111                pass.Function = ErasureMethod.Pass.WriteRandom; 
     
    121115            else 
    122116            { 
    123                 byte[] passConstant = ParseConstantStr(passTxt.Text, passTypeHex.Checked); 
    124117                pass.Function = ErasureMethod.Pass.WriteConstant; 
    125                 pass.OpaqueValue = passConstant; 
    126                 item.SubItems[1].Text = string.Format("Constant ({0} bytes)", passConstant.Length); 
    127             } 
    128         } 
    129  
    130         /// <summary> 
    131         /// Saves the pass constant currently in the pass constant text field. 
    132         /// </summary> 
    133         /// <param name="text">The text to parse.</param> 
    134         /// <param name="parseHex">Parse the constant in the field as a string of 
    135         /// hexadecimal numbers.</param> 
    136         /// <returns>An array containing the byte-wise representation of the input 
    137         /// string.</returns> 
    138         private static byte[] ParseConstantStr(string text, bool parseHex) 
    139         { 
    140             List<byte> passConstantList = new List<byte>(); 
    141             try 
    142             { 
    143                 if (parseHex) 
    144                 { 
    145                     string str = text.Replace(" ", "").ToUpper(); 
    146  
    147                     for (int i = 0, j = str.Length - 2; i < j; i += 2) 
    148                         passConstantList.Add(Convert.ToByte(str.Substring(i, 2), 16)); 
    149                     passConstantList.Add(Convert.ToByte(str.Substring(str.Length - 2), 16)); 
    150  
    151                     byte[] result = new byte[passConstantList.Count]; 
    152                     passConstantList.CopyTo(result); 
    153                     return result; 
    154                 } 
    155             } 
    156             catch (FormatException ex) 
    157             { 
    158                 MessageBox.Show(ex.Message, 
    159                     "Invalid input string", 
    160                     MessageBoxButtons.OK, MessageBoxIcon.Error); 
    161  
    162                 // return as much as we could comprehend 
    163                 byte[] result = new byte[passConstantList.Count]; 
    164                 passConstantList.CopyTo(result); 
    165                 return result; 
    166             } 
    167  
    168             return Encoding.UTF8.GetBytes(text); 
    169         } 
    170  
    171         /// <summary> 
    172         /// Displays the pass constant stored by the SavePassConstant function. 
    173         /// </summary> 
    174         /// <param name="array">The array containing the constant to display.</param> 
    175         /// <param name="asHex">Sets whether the array should be displayed as a 
    176         /// hexadecimal string.</param> 
    177         /// <returns>A string containing the user-visible representation of the 
    178         /// input array.</returns> 
    179         private static string DisplayConstantArray(byte[] array, bool asHex) 
    180         { 
    181             try 
    182             { 
    183                 if (asHex) 
    184                 { 
    185                     StringBuilder displayText = new StringBuilder(); 
    186                     foreach (byte b in array) 
    187                         displayText.Append(string.Format("{0,2} ", Convert.ToString(b, 16))); 
    188                     return displayText.ToString(); 
    189                 } 
    190             } 
    191             catch (FormatException ex) 
    192             { 
    193                 MessageBox.Show(ex.Message, 
    194                     "Invalid input string", 
    195                     MessageBoxButtons.OK, MessageBoxIcon.Error); 
    196             } 
    197  
    198             return Encoding.UTF8.GetString(array); 
     118                pass.OpaqueValue = passEditor.PassData; 
     119                item.SubItems[1].Text = string.Format("Constant ({0} bytes)", passEditor.PassData.Length); 
     120            } 
     121        } 
     122 
     123        /// <summary> 
     124        /// Displays the pass associated with <paramref name="item"/> in the editing controls. 
     125        /// </summary> 
     126        /// <param name="item">The <see cref="ListViewItem"/> containing the pass to edit.</param> 
     127        private void DisplayPass(ListViewItem item) 
     128        { 
     129            currentPass = item; 
     130            ErasureMethod.Pass pass = (ErasureMethod.Pass)item.Tag; 
     131            passEditor.PassData = (byte[])pass.OpaqueValue; 
     132            passEditor.PassType = pass.Function == EraseCustom.Pass.WriteRandom ? 
     133                CustomMethodPassEditor.PassTypes.RANDOM : 
     134                CustomMethodPassEditor.PassTypes.TEXT; 
    199135        } 
    200136 
     
    215151            passesRemoveBtn.Enabled = passesDuplicateBtn.Enabled = passesMoveUpBtn.Enabled = 
    216152                passesMoveDownBtn.Enabled = passesLv.SelectedItems.Count >= 1; 
    217             passGrp.Enabled = passTypeText.Enabled = passTypeHex.Enabled = 
    218                 passTypeRandom.Enabled = passTxt.Enabled = 
    219                 passesLv.SelectedItems.Count == 1; 
    220  
    221             ListView.SelectedIndexCollection indices = passesLv.SelectedIndices; 
    222             if (indices.Count > 0) 
    223             { 
    224                 int index = indices[indices.Count - 1]; 
    225                 passesMoveUpBtn.Enabled = passesMoveUpBtn.Enabled && index > 0; 
    226                 passesMoveDownBtn.Enabled = passesMoveDownBtn.Enabled && index < passesLv.Items.Count - 1; 
     153            passGrp.Enabled = passEditor.Enabled = passesLv.SelectedItems.Count == 1; 
     154 
     155            ListView.SelectedListViewItemCollection items = passesLv.SelectedItems; 
     156            if (items.Count > 0) 
     157            { 
     158                foreach (ListViewItem item in items) 
     159                { 
     160                    int index = item.Index; 
     161                    passesMoveUpBtn.Enabled = passesMoveUpBtn.Enabled && index > 0; 
     162                    passesMoveDownBtn.Enabled = passesMoveDownBtn.Enabled && index < passesLv.Items.Count - 1; 
     163                } 
    227164            } 
    228165        } 
     
    252189        private void passesDuplicateBtn_Click(object sender, EventArgs e) 
    253190        { 
    254             foreach (ListViewItem index in passesLv.SelectedItems) 
    255             { 
    256                 ListViewItem item = (ListViewItem)index.Clone(); 
    257                 ErasureMethod.Pass pass = (ErasureMethod.Pass)item.Tag; 
    258                 item.Text = (passesLv.Items.Count + 1).ToString(); 
    259                 item.Tag = new ErasureMethod.Pass(pass.Function, pass.OpaqueValue); 
    260                 passesLv.Items.Add(item); 
     191            foreach (ListViewItem item in passesLv.SelectedItems) 
     192            { 
     193                ErasureMethod.Pass oldPass = (ErasureMethod.Pass)item.Tag; 
     194                ErasureMethod.Pass pass = new ErasureMethod.Pass( 
     195                    oldPass.Function, oldPass.OpaqueValue); 
     196                AddPass(pass); 
    261197            } 
    262198        } 
     
    264200        private void passesMoveUpBtn_Click(object sender, EventArgs e) 
    265201        { 
    266             //Get the selection index 
    267             int selectedIndex = passesLv.SelectedIndices[0]; 
    268             if (selectedIndex == 0) 
    269                 return; 
    270  
    271             //Insert the current item into the index before. 
    272             ListViewItem item = passesLv.Items[selectedIndex]; 
    273             passesLv.Items.RemoveAt(selectedIndex); 
    274             passesLv.Items.Insert(selectedIndex - 1, item); 
     202            //Save the current pass to prevent data loss 
     203            SavePass(currentPass); 
     204 
     205            foreach (ListViewItem item in passesLv.SelectedItems) 
     206            { 
     207                //Insert the current item into the index before, only if the item has got 
     208                //space to move up! 
     209                int index = item.Index; 
     210                if (index >= 1) 
     211                { 
     212                    passesLv.Items.RemoveAt(index); 
     213                    passesLv.Items.Insert(index - 1, item); 
     214                } 
     215            } 
     216 
    275217            RenumberPasses(); 
    276218            EnableButtons(); 
     
    279221        private void passesMoveDownBtn_Click(object sender, EventArgs e) 
    280222        { 
    281             //Get the selection index 
    282             int selectedIndex = passesLv.SelectedIndices[0]; 
    283             if (selectedIndex == passesLv.Items.Count - 1) 
    284                 return; 
    285  
    286             //Insert the current item into the index after. 
    287             ListViewItem item = passesLv.Items[selectedIndex]; 
    288             passesLv.Items.RemoveAt(selectedIndex); 
    289             passesLv.Items.Insert(selectedIndex + 1, item); 
     223            //Save the current pass to prevent data loss 
     224            SavePass(currentPass); 
     225 
     226            ListView.SelectedListViewItemCollection items = passesLv.SelectedItems; 
     227            for (int i = items.Count; i-- != 0; ) 
     228            { 
     229                //Insert the current item into the index after, only if the item has got 
     230                //space to move down. 
     231                ListViewItem item = items[i]; 
     232                int index = item.Index; 
     233                if (index < passesLv.Items.Count - 1) 
     234                { 
     235                    passesLv.Items.RemoveAt(index); 
     236                    passesLv.Items.Insert(index + 1, item); 
     237                } 
     238            } 
     239 
    290240            RenumberPasses(); 
    291241            EnableButtons(); 
     
    300250            if (!e.Item.Selected) 
    301251            { 
    302                 if (passesLv.SelectedIndices.Count == 0 && passTxt.Text.Length > 0) 
     252                if (e.Item == currentPass) 
    303253                    SavePass(e.Item); 
    304254            } 
    305             else 
    306             { 
    307                 try 
    308                 { 
    309                     //Disable the pass display events 
    310                     passTypeText.CheckedChanged -= new EventHandler(passType_CheckedChanged); 
    311                     passTypeHex.CheckedChanged -= new EventHandler(passType_CheckedChanged); 
    312                     passTypeRandom.CheckedChanged -= new EventHandler(passType_CheckedChanged); 
    313  
    314                     //Get the pass data from the method structure. 
    315                     passTxt.Text = string.Empty; 
    316  
    317                     //Set the pass type to be undefined, to be set later. 
    318                     passTypeText.Checked = passTypeHex.Checked = passTypeRandom.Checked = false; 
    319                 } 
    320                 finally 
    321                 { 
    322                     //Reenable the pass display events 
    323                     passTypeText.CheckedChanged += new EventHandler(passType_CheckedChanged); 
    324                     passTypeHex.CheckedChanged += new EventHandler(passType_CheckedChanged); 
    325                     passTypeRandom.CheckedChanged += new EventHandler(passType_CheckedChanged); 
    326                 } 
    327  
    328                 //Set the pass type 
    329                 if (pass.Function == ErasureMethod.Pass.WriteRandom) 
    330                     passTypeRandom.Checked = true; 
    331                 else if (pass.Function == ErasureMethod.Pass.WriteConstant) 
    332                 { 
    333                     passTypeHex.Checked = true; 
    334                     passTxt.Text = DisplayConstantArray((byte[])pass.OpaqueValue, true); 
    335                 } 
    336                 else 
    337                     throw new ArgumentException("Unknown pass data."); 
    338             } 
    339  
    340             //Blank the pass text if it is not editable 
    341             if (!passTxt.Enabled) 
    342                 passTxt.Text = string.Empty; 
    343         } 
    344  
    345         private void passType_CheckedChanged(object sender, EventArgs e) 
    346         { 
    347             //Enable the text field if the selected pass type is not random data 
    348             passTxt.Enabled = !passTypeRandom.Checked; 
    349  
    350             //Copy or load the constant into the text field 
    351             if (sender != passTypeRandom && !passTypeRandom.Checked) 
    352             { 
    353                 byte[] constant = null; 
    354                 if (passTxt.Text.Length != 0) 
    355                     constant = ParseConstantStr(passTxt.Text, sender == passTypeHex); 
    356  
    357                 if (constant != null && constant.Length != 0) 
    358                     passTxt.Text = DisplayConstantArray(constant, passTypeHex.Checked); 
    359             } 
    360         } 
    361  
     255            else if (passesLv.SelectedIndices.Count == 1) 
     256            { 
     257                DisplayPass(passesLv.SelectedItems[0]); 
     258            } 
     259        } 
     260         
    362261        private void okBtn_Click(object sender, EventArgs e) 
    363262        { 
     
    387286            } 
    388287 
    389             foreach (ListViewItem item in passesLv.Items) 
    390             { 
    391                 ErasureMethod.Pass pass = (ErasureMethod.Pass)item.Tag; 
    392                 if (pass.Function == ErasureMethod.Pass.WriteConstant && 
    393                     (pass.OpaqueValue == null || ((byte[])pass.OpaqueValue).Length == 0)) 
    394                 { 
    395                     //Select the pass causing the error. 
    396                     passesLv.SelectedIndices.Clear(); 
    397                     passesLv.SelectedIndices.Add(passesLv.Items.IndexOf(item)); 
    398  
    399                     //Highlight the error 
    400                     errorProvider.SetError(passTxt, S._("The pass is supposed to write a " + 
    401                         "constant to the files to be erased, but no constant was defined.")); 
    402                     errorProvider.SetIconPadding(passTxt, -16); 
    403                     hasError = true; 
    404                     break; 
    405                 } 
    406             } 
    407  
    408288            //If there are errors, don't close the dialog. 
    409289            if (!hasError) 
     
    413293            } 
    414294        } 
     295 
     296        /// <summary> 
     297        /// Holds the CustomErasureMethod object which client code may set to allow 
     298        /// method editing. 
     299        /// </summary> 
     300        private CustomErasureMethod method; 
     301 
     302        /// <summary> 
     303        /// Holds the current Erasure pass that is being edited. 
     304        /// </summary> 
     305        private ListViewItem currentPass; 
    415306    } 
    416307} 
Note: See TracChangeset for help on using the changeset viewer.