Free cookie consent management tool by TermsFeed Policy Generator

source: stable/HeuristicLab.DataPreprocessing.Views/3.4/DataGridContentView.cs @ 17460

Last change on this file since 17460 was 17181, checked in by swagner, 5 years ago

#2875: Merged r17180 from trunk to stable

File size: 27.5 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using System.Windows.Forms;
26using HeuristicLab.Data;
27using HeuristicLab.Data.Views;
28using HeuristicLab.DataPreprocessing.Filter;
29using HeuristicLab.MainForm;
30
31namespace HeuristicLab.DataPreprocessing.Views {
32  [View("Data Grid Content View")]
33  [Content(typeof(DataGridContent), true)]
34  public partial class DataGridContentView : StringConvertibleMatrixView {
35    private bool isSearching = false;
36    private bool updateOnMouseUp = false;
37    private SearchAndReplaceDialog findAndReplaceDialog;
38    private IFindPreprocessingItemsIterator searchIterator;
39    private string currentSearchText;
40    private ComparisonOperation currentComparisonOperation;
41    private Tuple<int, int> currentCell;
42
43    public new DataGridContent Content {
44      get { return (DataGridContent)base.Content; }
45      set { base.Content = value; }
46    }
47
48    private IDictionary<int, IList<int>> _highlightedCellsBackground;
49    public IDictionary<int, IList<int>> HightlightedCellsBackground {
50      get { return _highlightedCellsBackground; }
51      set {
52        _highlightedCellsBackground = value;
53        Refresh();
54      }
55    }
56
57    public DataGridContentView() {
58      InitializeComponent();
59      dataGridView.MouseDown += dataGridView_MouseDown;
60      dataGridView.CellMouseClick += dataGridView_CellMouseClick;
61      dataGridView.RowHeaderMouseClick += dataGridView_RowHeaderMouseClick;
62      dataGridView.MouseUp += dataGridView_MouseUp;
63      contextMenuCell.Items.Add(ShowHideColumns);
64      _highlightedCellsBackground = new Dictionary<int, IList<int>>();
65      currentCell = null;
66    }
67
68    protected override void OnContentChanged() {
69      List<KeyValuePair<int, SortOrder>> order = new List<KeyValuePair<int, SortOrder>>(base.sortedColumnIndices);
70      base.OnContentChanged();
71
72      DataGridView.RowHeadersWidth = 70;
73
74      if (Content == null && findAndReplaceDialog != null) {
75        findAndReplaceDialog.Close();
76      }
77
78      if (Content != null) {
79        base.sortedColumnIndices = order;
80        base.Sort();
81      }
82    }
83
84    protected override void RegisterContentEvents() {
85      base.RegisterContentEvents();
86      Content.Changed += Content_Changed;
87      Content.PreprocessingData.FilterChanged += FilterLogic_FilterChanged;
88    }
89
90    protected override void DeregisterContentEvents() {
91      base.DeregisterContentEvents();
92      Content.Changed -= Content_Changed;
93      Content.PreprocessingData.FilterChanged -= FilterLogic_FilterChanged;
94    }
95
96    private void FilterLogic_FilterChanged(object sender, EventArgs e) {
97      OnContentChanged();
98      searchIterator = null;
99      if (findAndReplaceDialog != null && !findAndReplaceDialog.IsDisposed) {
100        if (Content.PreprocessingData.IsFiltered) {
101          findAndReplaceDialog.DisableReplace();
102        } else {
103          findAndReplaceDialog.EnableReplace();
104        }
105      }
106      btnReplace.Enabled = !Content.PreprocessingData.IsFiltered;
107    }
108
109    private void Content_Changed(object sender, DataPreprocessingChangedEventArgs e) {
110      OnContentChanged();
111      searchIterator = null;
112    }
113
114    protected override void dataGridView_SelectionChanged(object sender, EventArgs e) {
115      base.dataGridView_SelectionChanged(sender, e);
116      if (Content != null && dataGridView.RowCount != 0 && dataGridView.ColumnCount != 0)
117        Content.Selection = GetSelectedCells();
118    }
119
120    //couldn't use base.dataGridView_CellValidating as the values have to be validated per column individually
121    protected override void dataGridView_CellValidating(object sender, DataGridViewCellValidatingEventArgs e) {
122      if (dataGridView.ReadOnly) return;
123      if (Content == null) return;
124      if (Content.Rows == 0 || Content.Columns == 0) return;
125
126      string errorMessage;
127      if (!String.IsNullOrEmpty(e.FormattedValue.ToString())) {
128        if (dataGridView.IsCurrentCellInEditMode && Content.PreprocessingData.IsFiltered) {
129          errorMessage = "A filter is active, you cannot modify data. Press ESC to exit edit mode.";
130        } else {
131          Content.Validate(e.FormattedValue.ToString(), out errorMessage, e.ColumnIndex);
132        }
133
134        if (!String.IsNullOrEmpty(errorMessage)) {
135          e.Cancel = true;
136          dataGridView.Rows[e.RowIndex].ErrorText = errorMessage;
137        }
138
139      }
140    }
141
142    protected override void PasteValuesToDataGridView() {
143      string[,] values = SplitClipboardString(Clipboard.GetText());
144      if (values.Length == 0) return;
145      int rowIndex = 0;
146      int columnIndex = 0;
147      if (dataGridView.CurrentCell != null) {
148        rowIndex = dataGridView.CurrentCell.RowIndex;
149        columnIndex = dataGridView.CurrentCell.ColumnIndex;
150      }
151
152      bool containsHeader = false;
153      var firstRow = Enumerable.Range(0, values.GetLength(0)).Select(col => values[col, 0]).ToList();
154      if ((Content.Selection.Values.Sum(s => s.Count) == Content.Rows * Content.Columns)
155          || (rowIndex == 0 && columnIndex == 0 && Content.Rows <= values.GetLength(1) && Content.Columns <= values.GetLength(0))) {
156        // All is selected -or- top left selected and everything will be replaced
157        double temp;
158        containsHeader = !firstRow.All(string.IsNullOrEmpty) && firstRow.Any(r => !double.TryParse(r, out temp));
159        if (containsHeader)
160          rowIndex = columnIndex = 0;
161      }
162
163      int newRows = values.GetLength(1) + rowIndex - (containsHeader ? 1 : 0);
164      int newColumns = values.GetLength(0) + columnIndex;
165      if (Content.Rows < newRows) Content.Rows = newRows;
166      if (Content.Columns < newColumns) Content.Columns = newColumns;
167
168      ReplaceTransaction(() => {
169        Content.PreprocessingData.InTransaction(() => {
170          for (int row = containsHeader ? 1 : 0; row < values.GetLength(1); row++) {
171            for (int col = 0; col < values.GetLength(0); col++) {
172              Content.SetValue(values[col, row], row + rowIndex - (containsHeader ? 1 : 0), col + columnIndex);
173            }
174          }
175          if (containsHeader) {
176            for (int i = 0; i < firstRow.Count; i++)
177              if (string.IsNullOrWhiteSpace(firstRow[i]))
178                firstRow[i] = string.Format("<{0}>", i);
179            Content.PreprocessingData.RenameColumns(firstRow);
180          }
181        });
182      });
183
184      ClearSorting();
185    }
186
187    protected override void SetEnabledStateOfControls() {
188      base.SetEnabledStateOfControls();
189      rowsTextBox.ReadOnly = true;
190      columnsTextBox.ReadOnly = true;
191    }
192
193    protected override int[] Sort(IEnumerable<KeyValuePair<int, SortOrder>> sortedColumns) {
194      btnApplySort.Enabled = sortedColumns.Any();
195      return base.Sort(sortedColumns);
196    }
197
198    protected override void ClearSorting() {
199      btnApplySort.Enabled = false;
200      base.ClearSorting();
201    }
202
203    //Necessary so that dataGridView.SelectedRows and SelectedColumns are populated correctly
204    //further information: https://msdn.microsoft.com/en-us/library/system.windows.forms.datagridview.selectedcolumns.aspx
205    private void dataGridView_MouseDown(object sender, MouseEventArgs e) {
206      var hitTestInfo = dataGridView.HitTest(e.X, e.Y);
207      // row header click
208      if (hitTestInfo.ColumnIndex == -1 && hitTestInfo.RowIndex >= 0) {
209        if (dataGridView.SelectionMode != DataGridViewSelectionMode.RowHeaderSelect) {
210          dataGridView.SelectionMode = DataGridViewSelectionMode.RowHeaderSelect;
211        }
212      }
213      // column header click
214      if (hitTestInfo.RowIndex == -1 && hitTestInfo.ColumnIndex >= 0) {
215        if (dataGridView.SelectionMode != DataGridViewSelectionMode.ColumnHeaderSelect) {
216          dataGridView.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
217        }
218      }
219    }
220
221    protected override void dataGridView_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e) {
222      if (Content == null) return;
223
224      if (e.Button == MouseButtons.Middle) {
225        int newIndex = e.ColumnIndex >= 0 ? e.ColumnIndex : 0;
226        Content.PreprocessingData.InsertColumn<double>(newIndex.ToString(), newIndex);
227      } else if (e.Button == MouseButtons.Right && Content.SortableView) {
228        SortColumn(e.ColumnIndex);
229      }
230
231      searchIterator = null;
232    }
233    private void dataGridView_RowHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e) {
234      if (Content != null) {
235        if (e.Button == MouseButtons.Middle) {
236          int newIndex = e.RowIndex >= 0 ? e.RowIndex : 0;
237          Content.PreprocessingData.InsertRow(newIndex);
238        }
239      }
240    }
241
242    private void dataGridView_MouseUp(object sender, MouseEventArgs e) {
243      if (!updateOnMouseUp)
244        return;
245
246      updateOnMouseUp = false;
247      dataGridView_SelectionChanged(sender, e);
248    }
249
250    private void btnApplySort_Click(object sender, EventArgs e) {
251      Content.ReOrderToIndices(virtualRowIndices);
252      OnContentChanged();
253    }
254
255    #region FindAndReplaceDialog
256
257    private void CreateFindAndReplaceDialog() {
258      if (findAndReplaceDialog == null || findAndReplaceDialog.IsDisposed) {
259        findAndReplaceDialog = new SearchAndReplaceDialog();
260        findAndReplaceDialog.Show(this);
261        if (AreMultipleCellsSelected()) {
262          ResetHighlightedCellsBackground();
263          HightlightedCellsBackground = GetSelectedCells();
264          dataGridView.ClearSelection();
265        }
266        findAndReplaceDialog.FindAllEvent += findAndReplaceDialog_FindAllEvent;
267        findAndReplaceDialog.FindNextEvent += findAndReplaceDialog_FindNextEvent;
268        findAndReplaceDialog.ReplaceAllEvent += findAndReplaceDialog_ReplaceAllEvent;
269        findAndReplaceDialog.ReplaceNextEvent += findAndReplaceDialog_ReplaceEvent;
270        findAndReplaceDialog.FormClosing += findAndReplaceDialog_FormClosing;
271        searchIterator = null;
272        DataGridView.SelectionChanged += DataGridView_SelectionChanged_FindAndReplace;
273        if (Content.PreprocessingData.IsFiltered) {
274          findAndReplaceDialog.DisableReplace();
275        }
276      }
277    }
278
279    private void DataGridView_SelectionChanged_FindAndReplace(object sender, EventArgs e) {
280      if (Content != null) {
281        if (!isSearching && AreMultipleCellsSelected()) {
282          ResetHighlightedCellsBackground();
283          HightlightedCellsBackground = GetSelectedCells();
284          searchIterator = null;
285        }
286      }
287    }
288
289    void findAndReplaceDialog_FormClosing(object sender, FormClosingEventArgs e) {
290      ResetHighlightedCellsBackground();
291      searchIterator = null;
292      DataGridView.SelectionChanged -= DataGridView_SelectionChanged_FindAndReplace;
293    }
294
295    void findAndReplaceDialog_ReplaceEvent(object sender, EventArgs e) {
296      if (searchIterator != null && searchIterator.GetCurrent() != null) {
297        Replace(TransformToDictionary(currentCell));
298      }
299    }
300
301    void findAndReplaceDialog_ReplaceAllEvent(object sender, EventArgs e) {
302      Replace(FindAll(findAndReplaceDialog.GetSearchText()));
303    }
304
305    void findAndReplaceDialog_FindNextEvent(object sender, EventArgs e) {
306      if (searchIterator == null
307        || currentSearchText != findAndReplaceDialog.GetSearchText()
308        || currentComparisonOperation != findAndReplaceDialog.GetComparisonOperation()) {
309
310        searchIterator = new FindPreprocessingItemsIterator(FindAll(findAndReplaceDialog.GetSearchText()));
311        currentSearchText = findAndReplaceDialog.GetSearchText();
312        currentComparisonOperation = findAndReplaceDialog.GetComparisonOperation();
313      }
314
315      if (IsOneCellSelected()) {
316        var first = GetSelectedCells().First();
317        searchIterator.SetStartCell(first.Key, first.Value[0]);
318      }
319
320      bool moreOccurences = false;
321      currentCell = searchIterator.GetCurrent();
322      moreOccurences = searchIterator.MoveNext();
323      if (IsOneCellSelected() && currentCell != null) {
324        var first = GetSelectedCells().First();
325        if (currentCell.Item1 == first.Key && currentCell.Item2 == first.Value[0]) {
326          if (!moreOccurences) {
327            searchIterator.Reset();
328          }
329          currentCell = searchIterator.GetCurrent();
330          moreOccurences = searchIterator.MoveNext();
331          if (!moreOccurences) {
332            searchIterator.Reset();
333          }
334        }
335      }
336
337      dataGridView.ClearSelection();
338
339      if (currentCell != null) {
340        dataGridView[currentCell.Item1, currentCell.Item2].Selected = true;
341        dataGridView.CurrentCell = dataGridView[currentCell.Item1, currentCell.Item2];
342      }
343    }
344
345    private bool AreMultipleCellsSelected() {
346      return GetSelectedCellCount() > 1;
347    }
348
349    private bool IsOneCellSelected() {
350      return GetSelectedCellCount() == 1;
351    }
352
353    private int GetSelectedCellCount() {
354      int count = 0;
355      foreach (var column in GetSelectedCells()) {
356        count += column.Value.Count();
357      }
358      return count;
359    }
360
361    void findAndReplaceDialog_FindAllEvent(object sender, EventArgs e) {
362      dataGridView.ClearSelection();
363      isSearching = true;
364      SuspendRepaint();
365      var selectedCells = FindAll(findAndReplaceDialog.GetSearchText());
366      foreach (var column in selectedCells) {
367        foreach (var cell in column.Value) {
368          dataGridView[column.Key, cell].Selected = true;
369        }
370      }
371      ResumeRepaint(true);
372      isSearching = false;
373      Content.Selection = selectedCells;
374      //update statistic in base
375      base.dataGridView_SelectionChanged(sender, e);
376    }
377
378    private Core.ConstraintOperation GetConstraintOperation(ComparisonOperation comparisonOperation) {
379      Core.ConstraintOperation constraintOperation = Core.ConstraintOperation.Equal;
380      switch (comparisonOperation) {
381        case ComparisonOperation.Equal:
382          constraintOperation = Core.ConstraintOperation.Equal;
383          break;
384        case ComparisonOperation.Greater:
385          constraintOperation = Core.ConstraintOperation.Greater;
386          break;
387        case ComparisonOperation.GreaterOrEqual:
388          constraintOperation = Core.ConstraintOperation.GreaterOrEqual;
389          break;
390        case ComparisonOperation.Less:
391          constraintOperation = Core.ConstraintOperation.Less;
392          break;
393        case ComparisonOperation.LessOrEqual:
394          constraintOperation = Core.ConstraintOperation.LessOrEqual;
395          break;
396        case ComparisonOperation.NotEqual:
397          constraintOperation = Core.ConstraintOperation.NotEqual;
398          break;
399      }
400      return constraintOperation;
401    }
402
403    private IDictionary<int, IList<int>> FindAll(string match) {
404      bool searchInSelection = HightlightedCellsBackground.Values.Sum(list => list.Count) > 1;
405      ComparisonOperation comparisonOperation = findAndReplaceDialog.GetComparisonOperation();
406      var foundCells = new Dictionary<int, IList<int>>();
407      for (int i = 0; i < Content.PreprocessingData.Columns; i++) {
408        var filters = CreateFilters(match, comparisonOperation, i);
409
410        bool[] filteredRows = GetFilterResult(filters, true);
411        var foundIndices = new List<int>();
412        for (int idx = 0; idx < filteredRows.Length; ++idx) {
413          if (filteredRows[idx]) {
414            foundIndices.Add(idx);
415          }
416        }
417        foundCells[i] = foundIndices;
418        IList<int> selectedList;
419        if (searchInSelection && HightlightedCellsBackground.TryGetValue(i, out selectedList)) {
420          foundCells[i] = foundCells[i].Intersect(selectedList).ToList<int>();
421        } else if (searchInSelection) {
422          foundCells[i].Clear();
423        }
424      }
425      return MapToSorting(foundCells);
426    }
427
428    private bool[] GetFilterResult(IList<IFilter> filters, bool isAndCombination) {
429      IList<IFilter> activeFilters = filters.Where(f => f.Active && f.ConstraintData != null).ToList();
430
431      if (activeFilters.Count == 0) {
432        return Enumerable.Repeat(false, Content.PreprocessingData.Rows).ToArray(); ;
433      }
434
435      var result = Enumerable.Repeat(!isAndCombination, Content.PreprocessingData.Rows).ToArray();
436      foreach (IFilter filter in activeFilters) {
437        bool[] filterResult = filter.Check();
438        for (int row = 0; row < result.Length; ++row) {
439          result[row] = isAndCombination ? result[row] || filterResult[row] : result[row] && filterResult[row];
440        }
441      }
442      return result;
443    }
444
445    private List<IFilter> CreateFilters(string match, ComparisonOperation comparisonOperation, int columnIndex) {
446      IPreprocessingData preprocessingData = Content.PreprocessingData;
447      IStringConvertibleValue value;
448      if (preprocessingData.VariableHasType<double>(columnIndex)) {
449        value = new DoubleValue();
450      } else if (preprocessingData.VariableHasType<String>(columnIndex)) {
451        value = new StringValue();
452      } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
453        value = new DateTimeValue();
454      } else {
455        throw new ArgumentException("unsupported type");
456      }
457      value.SetValue(match);
458      var comparisonFilter = new ComparisonFilter(preprocessingData, GetConstraintOperation(comparisonOperation), value, true);
459      comparisonFilter.ConstraintColumn = columnIndex;
460      return new List<Filter.IFilter>() { comparisonFilter };
461    }
462
463    private IDictionary<int, IList<int>> MapToSorting(Dictionary<int, IList<int>> foundCells) {
464      if (sortedColumnIndices.Count == 0) {
465        return foundCells;
466      } else {
467        var sortedFoundCells = new Dictionary<int, IList<int>>();
468
469        var indicesToVirtual = new Dictionary<int, int>();
470        for (int i = 0; i < virtualRowIndices.Length; ++i) {
471          indicesToVirtual.Add(virtualRowIndices[i], i);
472        }
473
474        foreach (var entry in foundCells) {
475          var cells = new List<int>();
476          foreach (var cell in entry.Value) {
477            cells.Add(indicesToVirtual[cell]);
478          }
479          cells.Sort();
480          sortedFoundCells.Add(entry.Key, cells);
481        }
482        return sortedFoundCells;
483      }
484    }
485
486    private void Replace(IDictionary<int, IList<int>> cells) {
487      if (findAndReplaceDialog != null) {
488        ReplaceTransaction(() => {
489          switch (findAndReplaceDialog.GetReplaceAction()) {
490            case ReplaceAction.Value:
491              Content.ReplaceIndicesByString(cells, findAndReplaceDialog.GetReplaceText());
492              break;
493            case ReplaceAction.Average:
494              Content.ReplaceIndicesByMean(cells, false);
495              break;
496            case ReplaceAction.Median:
497              Content.ReplaceIndicesByMedianValue(cells, false);
498              break;
499            case ReplaceAction.Random:
500              Content.ReplaceIndicesByRandomValue(cells, false);
501              break;
502            case ReplaceAction.MostCommon:
503              Content.ReplaceIndicesByMode(cells, false);
504              break;
505            case ReplaceAction.Interpolation:
506              Content.ReplaceIndicesByLinearInterpolationOfNeighbours(cells);
507              break;
508          }
509        });
510      }
511    }
512
513    private IDictionary<int, IList<int>> TransformToDictionary(Tuple<int, int> tuple) {
514      var highlightCells = new Dictionary<int, IList<int>>();
515      highlightCells.Add(tuple.Item1, new List<int>() { tuple.Item2 });
516      return highlightCells;
517    }
518
519    private void ResetHighlightedCellsBackground() {
520      HightlightedCellsBackground = new Dictionary<int, IList<int>>();
521    }
522
523    #endregion FindAndReplaceDialog
524    private void dataGridView_CellMouseClick(object sender, DataGridViewCellMouseEventArgs e) {
525      if (Content == null) return;
526      if (e.Button == MouseButtons.Right && !(e.ColumnIndex != -1 && e.RowIndex == -1)) {
527        if (e.ColumnIndex == -1 || e.RowIndex == -1) {
528          replaceValueOverColumnToolStripMenuItem.Visible = false;
529          contextMenuCell.Show(MousePosition);
530        } else {
531          if (!dataGridView.SelectedCells.Contains(dataGridView[e.ColumnIndex, e.RowIndex])) {
532            dataGridView.ClearSelection();
533            dataGridView[e.ColumnIndex, e.RowIndex].Selected = true;
534          }
535
536          var columnIndices = new HashSet<int>();
537          for (int i = 0; i < dataGridView.SelectedCells.Count; i++) {
538            columnIndices.Add(dataGridView.SelectedCells[i].ColumnIndex);
539          }
540
541          replaceValueOverSelectionToolStripMenuItem.Enabled = AreMultipleCellsSelected();
542
543          averageToolStripMenuItem_Column.Enabled =
544            averageToolStripMenuItem_Selection.Enabled =
545            medianToolStripMenuItem_Column.Enabled =
546            medianToolStripMenuItem_Selection.Enabled =
547            randomToolStripMenuItem_Column.Enabled =
548            randomToolStripMenuItem_Selection.Enabled = !Content.PreprocessingData.AreAllStringColumns(columnIndices);
549
550          replaceValueOverColumnToolStripMenuItem.Visible = true;
551          contextMenuCell.Show(MousePosition);
552        }
553      }
554    }
555
556    protected override void dataGridView_KeyDown(object sender, KeyEventArgs e) {
557      base.dataGridView_KeyDown(sender, e);
558      //data is in read only mode....
559      if (Content.PreprocessingData.IsFiltered) return;
560
561      if (e.KeyCode == Keys.Delete) {
562        //Delete column
563        if (dataGridView.SelectedColumns.Count > 0) {
564          var columnsToDelete = dataGridView.SelectedColumns.Cast<DataGridViewColumn>().OrderByDescending(col => col.Index).ToList();
565          foreach (var col in columnsToDelete)
566            Content.DeleteColumn(col.Index);
567        }
568        //Delete row
569        if (dataGridView.SelectedRows.Count > 0) {
570          //necessary if columns are sorted to translate the selected row index
571          var rowIndexes = dataGridView.SelectedRows.Cast<DataGridViewRow>().Select(row => GetRowIndex(row.Index)).ToList();
572          Content.DeleteRows(rowIndexes);
573        }
574      } else if (e.Control && e.KeyCode == Keys.F) {
575        CreateFindAndReplaceDialog();
576        findAndReplaceDialog.ActivateSearch();
577      } else if (e.Control && e.KeyCode == Keys.R) {
578        CreateFindAndReplaceDialog();
579        findAndReplaceDialog.ActivateReplace();
580      }
581    }
582
583    private IDictionary<int, IList<int>> GetSelectedCells() {
584      IDictionary<int, IList<int>> selectedCells = new Dictionary<int, IList<int>>();
585
586      //special case if all cells are selected
587      if (dataGridView.AreAllCellsSelected(true)) {
588        for (int i = 0; i < Content.Columns; i++)
589          selectedCells[i] = Enumerable.Range(0, Content.Rows).ToList();
590        return selectedCells;
591      }
592
593      foreach (DataGridViewCell cell in dataGridView.SelectedCells) {
594        if (!selectedCells.ContainsKey(cell.ColumnIndex))
595          selectedCells.Add(cell.ColumnIndex, new List<int>());
596        selectedCells[cell.ColumnIndex].Add(cell.RowIndex);
597      }
598
599      return selectedCells;
600    }
601
602    private void ReplaceTransaction(Action action) {
603      SuspendRepaint();
604      action();
605      ResumeRepaint(true);
606    }
607
608    private void btnSearch_Click(object sender, EventArgs e) {
609      CreateFindAndReplaceDialog();
610      findAndReplaceDialog.ActivateSearch();
611    }
612
613    private void btnReplace_Click(object sender, EventArgs e) {
614      CreateFindAndReplaceDialog();
615      findAndReplaceDialog.ActivateReplace();
616    }
617
618    #region ContextMenu Events
619    private void ReplaceWithAverage_Column_Click(object sender, EventArgs e) {
620      ReplaceTransaction(() => {
621        Content.ReplaceIndicesByMean(GetSelectedCells(), false);
622      });
623    }
624    private void ReplaceWithAverage_Selection_Click(object sender, EventArgs e) {
625      ReplaceTransaction(() => {
626        Content.ReplaceIndicesByMean(GetSelectedCells(), true);
627      });
628    }
629
630    private void ReplaceWithMedian_Column_Click(object sender, EventArgs e) {
631      ReplaceTransaction(() => {
632        Content.ReplaceIndicesByMedianValue(GetSelectedCells(), false);
633      });
634    }
635    private void ReplaceWithMedian_Selection_Click(object sender, EventArgs e) {
636      ReplaceTransaction(() => {
637        Content.ReplaceIndicesByMedianValue(GetSelectedCells(), true);
638      });
639    }
640
641    private void ReplaceWithRandom_Column_Click(object sender, EventArgs e) {
642      ReplaceTransaction(() => {
643        Content.ReplaceIndicesByRandomValue(GetSelectedCells(), false);
644      });
645    }
646    private void ReplaceWithRandom_Selection_Click(object sender, EventArgs e) {
647      ReplaceTransaction(() => {
648        Content.ReplaceIndicesByRandomValue(GetSelectedCells(), true);
649      });
650    }
651
652    private void ReplaceWithMostCommon_Column_Click(object sender, EventArgs e) {
653      ReplaceTransaction(() => {
654        Content.ReplaceIndicesByMode(GetSelectedCells(), false);
655      });
656    }
657    private void ReplaceWithMostCommon_Selection_Click(object sender, EventArgs e) {
658      ReplaceTransaction(() => {
659        Content.ReplaceIndicesByMode(GetSelectedCells(), true);
660      });
661    }
662
663    private void ReplaceWithInterpolation_Column_Click(object sender, EventArgs e) {
664      ReplaceTransaction(() => {
665        Content.ReplaceIndicesByLinearInterpolationOfNeighbours(GetSelectedCells());
666      });
667    }
668    #endregion
669
670    private void addRowButton_Click(object sender, EventArgs e) {
671      Content.PreprocessingData.InsertRow(Content.Rows);
672    }
673
674    private void addColumnButton_Click(object sender, EventArgs e) {
675      Content.PreprocessingData.InsertColumn<double>(Content.Columns.ToString(), Content.Columns);
676    }
677
678    private void renameColumnsButton_Click(object sender, EventArgs e) {
679      var renameDialog = new RenameColumnsDialog(Content.ColumnNames);
680
681      if (renameDialog.ShowDialog(this) == DialogResult.OK) {
682        Content.PreprocessingData.RenameColumns(renameDialog.ColumnNames);
683      }
684    }
685
686    private void checkInputsTargetButton_Click(object sender, EventArgs e) {
687      foreach (DataGridViewColumn column in DataGridView.Columns) {
688        var variable = column.HeaderText;
689        bool isInputTarget = Content.PreprocessingData.InputVariables.Contains(variable)
690          || Content.PreprocessingData.TargetVariable == variable;
691        column.Visible = isInputTarget;
692      }
693    }
694
695    private void checkAllButton_Click(object sender, EventArgs e) {
696      foreach (DataGridViewColumn column in DataGridView.Columns) {
697        column.Visible = true;
698      }
699    }
700
701    private void uncheckAllButton_Click(object sender, EventArgs e) {
702      foreach (DataGridViewColumn column in DataGridView.Columns) {
703        column.Visible = false;
704      }
705    }
706
707    private void shuffleAllButton_Click(object sender, EventArgs e) {
708      Content.Shuffle(shuffleWithinPartitionsCheckBox.Checked);
709    }
710  }
711}
Note: See TracBrowser for help on using the repository browser.