Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.cs

Last change on this file was 18166, checked in by gkronber, 2 years ago

#3047: set SuppressKeyPress=true in all controls that handle the Enter key explicitly (except for dialogs).

File size: 24.0 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.ComponentModel;
25using System.Drawing;
26using System.Linq;
27using System.Text;
28using System.Windows.Forms;
29using HeuristicLab.Common;
30using HeuristicLab.MainForm;
31using HeuristicLab.MainForm.WindowsForms;
32
33namespace HeuristicLab.Data.Views {
34  [View("StringConvertibleMatrix View")]
35  [Content(typeof(IStringConvertibleMatrix), true)]
36  public partial class StringConvertibleMatrixView : AsynchronousContentView {
37    protected int[] virtualRowIndices;
38    protected List<KeyValuePair<int, SortOrder>> sortedColumnIndices;
39    private RowComparer rowComparer;
40
41    public new IStringConvertibleMatrix Content {
42      get { return (IStringConvertibleMatrix)base.Content; }
43      set { base.Content = value; }
44    }
45
46    public DataGridView DataGridView {
47      get { return dataGridView; }
48    }
49
50    public override bool ReadOnly {
51      get {
52        if ((Content != null) && Content.ReadOnly) return true;
53        return base.ReadOnly;
54      }
55      set { base.ReadOnly = value; }
56    }
57
58    private bool showRowsAndColumnsTextBox;
59    public bool ShowRowsAndColumnsTextBox {
60      get { return showRowsAndColumnsTextBox; }
61      set {
62        showRowsAndColumnsTextBox = value;
63        UpdateVisibilityOfTextBoxes();
64      }
65    }
66
67    private bool showStatisticalInformation;
68    public bool ShowStatisticalInformation {
69      get { return showStatisticalInformation; }
70      set {
71        showStatisticalInformation = value;
72        UpdateVisibilityOfStatisticalInformation();
73      }
74    }
75
76    public StringConvertibleMatrixView() {
77      InitializeComponent();
78      ShowRowsAndColumnsTextBox = true;
79      ShowStatisticalInformation = true;
80      errorProvider.SetIconAlignment(rowsTextBox, ErrorIconAlignment.MiddleLeft);
81      errorProvider.SetIconPadding(rowsTextBox, 2);
82      errorProvider.SetIconAlignment(columnsTextBox, ErrorIconAlignment.MiddleLeft);
83      errorProvider.SetIconPadding(columnsTextBox, 2);
84      sortedColumnIndices = new List<KeyValuePair<int, SortOrder>>();
85      rowComparer = new RowComparer();
86    }
87
88    protected override void DeregisterContentEvents() {
89      Content.ItemChanged -= new EventHandler<EventArgs<int, int>>(Content_ItemChanged);
90      Content.Reset -= new EventHandler(Content_Reset);
91      Content.ColumnNamesChanged -= new EventHandler(Content_ColumnNamesChanged);
92      Content.RowNamesChanged -= new EventHandler(Content_RowNamesChanged);
93      base.DeregisterContentEvents();
94    }
95    protected override void RegisterContentEvents() {
96      base.RegisterContentEvents();
97      Content.ItemChanged += new EventHandler<EventArgs<int, int>>(Content_ItemChanged);
98      Content.Reset += new EventHandler(Content_Reset);
99      Content.ColumnNamesChanged += new EventHandler(Content_ColumnNamesChanged);
100      Content.RowNamesChanged += new EventHandler(Content_RowNamesChanged);
101    }
102
103    protected override void OnContentChanged() {
104      base.OnContentChanged();
105      if (Content == null) {
106        rowsTextBox.Text = "";
107        columnsTextBox.Text = "";
108        dataGridView.Rows.Clear();
109        dataGridView.Columns.Clear();
110        virtualRowIndices = new int[0];
111      } else if (!dataGridView.IsCurrentCellInEditMode) {
112        UpdateData();
113      }
114    }
115
116    protected override void SetEnabledStateOfControls() {
117      base.SetEnabledStateOfControls();
118      rowsTextBox.Enabled = Content != null;
119      columnsTextBox.Enabled = Content != null;
120      dataGridView.Enabled = Content != null;
121      rowsTextBox.ReadOnly = ReadOnly;
122      columnsTextBox.ReadOnly = ReadOnly;
123      dataGridView.ReadOnly = ReadOnly;
124    }
125
126    protected virtual void UpdateData() {
127      rowsTextBox.Text = Content.Rows.ToString();
128      rowsTextBox.Enabled = true;
129      columnsTextBox.Text = Content.Columns.ToString();
130      columnsTextBox.Enabled = true;
131      virtualRowIndices = Enumerable.Range(0, Content.Rows).ToArray();
132
133
134      dataGridView.RowCount = 0;
135
136      DataGridViewColumn[] columns = new DataGridViewColumn[Content.Columns];
137      for (int i = 0; i < columns.Length; ++i) {
138        var column = new DataGridViewTextBoxColumn();
139        column.SortMode = DataGridViewColumnSortMode.Programmatic;
140        column.FillWeight = 1;
141        columns[i] = column;
142      }
143      dataGridView.Columns.Clear();
144
145      if (Content.Columns != 0) {
146        dataGridView.Columns.AddRange(columns);
147        dataGridView.RowCount = Content.Rows;
148      }
149
150      ClearSorting();
151      UpdateColumnHeaders();
152      UpdateRowHeaders();
153
154      dataGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.ColumnHeader);
155      dataGridView.AutoResizeRowHeadersWidth(DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders);
156      dataGridView.Enabled = true;
157    }
158
159    public virtual void UpdateColumnHeaders() {
160      HashSet<string> invisibleColumnNames = new HashSet<string>(dataGridView.Columns.OfType<DataGridViewColumn>()
161      .Where(c => !c.Visible && !string.IsNullOrEmpty(c.HeaderText)).Select(c => c.HeaderText));
162
163      for (int i = 0; i < dataGridView.ColumnCount; i++) {
164        if (i < Content.ColumnNames.Count())
165          dataGridView.Columns[i].HeaderText = Content.ColumnNames.ElementAt(i);
166        else
167          dataGridView.Columns[i].HeaderText = "Column " + (i + 1);
168        dataGridView.Columns[i].Visible = !invisibleColumnNames.Contains(dataGridView.Columns[i].HeaderText);
169      }
170    }
171    public virtual void UpdateRowHeaders() {
172      int index = dataGridView.FirstDisplayedScrollingRowIndex;
173      if (index == -1) index = 0;
174      int updatedRows = 0;
175      int count = dataGridView.DisplayedRowCount(true);
176
177      while (updatedRows < count) {
178        if (virtualRowIndices[index] < Content.RowNames.Count())
179          dataGridView.Rows[index].HeaderCell.Value = Content.RowNames.ElementAt(virtualRowIndices[index]);
180        else
181          dataGridView.Rows[index].HeaderCell.Value = "Row " + (index + 1);
182        if (dataGridView.Rows[index].Visible)
183          updatedRows++;
184        index++;
185      }
186    }
187
188    private void Content_RowNamesChanged(object sender, EventArgs e) {
189      if (InvokeRequired)
190        Invoke(new EventHandler(Content_RowNamesChanged), sender, e);
191      else
192        UpdateRowHeaders();
193    }
194    private void Content_ColumnNamesChanged(object sender, EventArgs e) {
195      if (InvokeRequired)
196        Invoke(new EventHandler(Content_ColumnNamesChanged), sender, e);
197      else
198        UpdateColumnHeaders();
199    }
200    private void Content_ItemChanged(object sender, EventArgs<int, int> e) {
201      if (InvokeRequired)
202        Invoke(new EventHandler<EventArgs<int, int>>(Content_ItemChanged), sender, e);
203      else
204        dataGridView.InvalidateCell(e.Value2, e.Value);
205    }
206    private void Content_Reset(object sender, EventArgs e) {
207      if (InvokeRequired)
208        Invoke(new EventHandler(Content_Reset), sender, e);
209      else
210        UpdateData();
211    }
212
213    #region TextBox Events
214    private void rowsTextBox_Validating(object sender, CancelEventArgs e) {
215      if (ReadOnly || Locked)
216        return;
217      int i = 0;
218      if (!int.TryParse(rowsTextBox.Text, out i) || (i <= 0)) {
219        e.Cancel = true;
220        errorProvider.SetError(rowsTextBox, "Invalid Number of Rows (Valid values are positive integers larger than 0)");
221        rowsTextBox.SelectAll();
222      }
223    }
224    private void rowsTextBox_Validated(object sender, EventArgs e) {
225      if (!Content.ReadOnly) Content.Rows = int.Parse(rowsTextBox.Text);
226      errorProvider.SetError(rowsTextBox, string.Empty);
227    }
228    private void rowsTextBox_KeyDown(object sender, KeyEventArgs e) {
229      if (e.KeyCode == Keys.Enter || e.KeyCode == Keys.Return) {
230        rowsLabel.Focus();  // set focus on label to validate data
231        e.SuppressKeyPress = true;
232      } else if (e.KeyCode == Keys.Escape) {
233        rowsTextBox.Text = Content.Rows.ToString();
234        rowsLabel.Focus();  // set focus on label to validate data
235        e.SuppressKeyPress = true;
236      }
237    }
238    private void columnsTextBox_Validating(object sender, CancelEventArgs e) {
239      if (ReadOnly || Locked)
240        return;
241      int i = 0;
242      if (!int.TryParse(columnsTextBox.Text, out i) || (i <= 0)) {
243        e.Cancel = true;
244        errorProvider.SetError(columnsTextBox, "Invalid Number of Columns (Valid values are positive integers larger than 0)");
245        columnsTextBox.SelectAll();
246      }
247    }
248    private void columnsTextBox_Validated(object sender, EventArgs e) {
249      if (!Content.ReadOnly) Content.Columns = int.Parse(columnsTextBox.Text);
250      errorProvider.SetError(columnsTextBox, string.Empty);
251    }
252    private void columnsTextBox_KeyDown(object sender, KeyEventArgs e) {
253      if (e.KeyCode == Keys.Enter || e.KeyCode == Keys.Return) {
254        columnsLabel.Focus();  // set focus on label to validate data
255        e.SuppressKeyPress = true;
256      } else if (e.KeyCode == Keys.Escape) {
257        columnsTextBox.Text = Content.Columns.ToString();
258        columnsLabel.Focus();  // set focus on label to validate data
259        e.SuppressKeyPress = true;
260      }
261    }
262    #endregion
263
264    #region DataGridView Events
265
266    protected virtual void dataGridView_CellValidating(object sender, DataGridViewCellValidatingEventArgs e) {
267      if (dataGridView.ReadOnly) return;
268      if (Content == null) return;
269      if (Content.Rows <= e.RowIndex || Content.Columns <= e.ColumnIndex) return;
270
271      string errorMessage;
272      if (!Content.Validate(e.FormattedValue.ToString(), out errorMessage)) {
273        e.Cancel = true;
274        dataGridView.Rows[e.RowIndex].ErrorText = errorMessage;
275      }
276    }
277
278    protected virtual void dataGridView_CellParsing(object sender, DataGridViewCellParsingEventArgs e) {
279      if (!dataGridView.ReadOnly) {
280        string value = e.Value.ToString();
281        int rowIndex = virtualRowIndices[e.RowIndex];
282        e.ParsingApplied = Content.SetValue(value, rowIndex, e.ColumnIndex);
283        if (e.ParsingApplied) e.Value = Content.GetValue(rowIndex, e.ColumnIndex);
284      }
285    }
286    private void dataGridView_CellEndEdit(object sender, DataGridViewCellEventArgs e) {
287      dataGridView.Rows[e.RowIndex].ErrorText = string.Empty;
288    }
289    protected virtual void dataGridView_CellValueNeeded(object sender, DataGridViewCellValueEventArgs e) {
290      if (Content != null && e.RowIndex < Content.Rows && e.ColumnIndex < Content.Columns) {
291        int rowIndex = virtualRowIndices[e.RowIndex];
292        e.Value = Content.GetValue(rowIndex, e.ColumnIndex);
293      }
294    }
295
296    private void dataGridView_Scroll(object sender, System.Windows.Forms.ScrollEventArgs e) {
297      this.UpdateRowHeaders();
298    }
299    private void dataGridView_Resize(object sender, EventArgs e) {
300      this.UpdateRowHeaders();
301    }
302
303    protected virtual void dataGridView_KeyDown(object sender, KeyEventArgs e) {
304      if (!ReadOnly && e.Control && e.KeyCode == Keys.V) {
305        PasteValuesToDataGridView();
306        e.Handled = true;
307      } else if (e.Control && e.KeyCode == Keys.C) {
308        CopyValuesFromDataGridView();
309        e.Handled = true;
310      }
311    }
312
313    private void CopyValuesFromDataGridView() {
314      if (dataGridView.SelectedCells.Count == 0) return;
315
316      //if not all cells are selected use the built-in functionality for copying values to the clipboard
317      if (!dataGridView.AreAllCellsSelected(false)) {
318        dataGridView.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableWithoutHeaderText;
319        var data = dataGridView.GetClipboardContent();
320        Clipboard.SetDataObject(data);
321        return;
322      }
323
324      //If all cells are selected we want to include row and column headers if they are set in the content.
325      //This is not possible with the built-in functionality, because only both headers can be added.
326      //Furthermore, the current implementation of the view with the virtual DataGridView does set
327      //Row headers only when they are displayed (see UpdateRowHeaders) and otherwise leaves them empty.
328
329      StringBuilder s = new StringBuilder();
330
331      bool addColumnNames = Content.ColumnNames.Any();
332      bool addRowNames = Content.RowNames.Any();
333
334      //add first row with column headers
335      if (addColumnNames) {
336        var columnNames = Content.ColumnNames.ToArray();
337        if (addRowNames) s.Append('\t'); //there is no column header for the row headers
338        DataGridViewColumn column = dataGridView.Columns.GetFirstColumn(DataGridViewElementStates.Visible);
339        while (column != null) {
340          s.Append(columnNames[column.Index]);
341          s.Append('\t');
342
343          column = dataGridView.Columns.GetNextColumn(column, DataGridViewElementStates.Visible, DataGridViewElementStates.None);
344        }
345        s.Append(Environment.NewLine);
346      }
347
348      var rowNames = Content.RowNames.ToArray();
349      for (int r = 0; r < dataGridView.RowCount; r++) {
350        if (!dataGridView.Rows[r].Visible) continue; //skip invisible rows
351
352        int rowIndex = virtualRowIndices[r];
353        if (addRowNames) {
354          s.Append(rowNames[rowIndex]);
355          s.Append('\t');
356        }
357
358        DataGridViewColumn column = dataGridView.Columns.GetFirstColumn(DataGridViewElementStates.Visible);
359        while (column != null) {
360          s.Append(Content.GetValue(rowIndex, column.Index));
361          s.Append('\t');
362
363          column = dataGridView.Columns.GetNextColumn(column, DataGridViewElementStates.Visible, DataGridViewElementStates.None);
364        }
365
366        s.Remove(s.Length - 1, 1); //remove last tab
367        s.Append(Environment.NewLine);
368      }
369
370      Clipboard.SetText(s.ToString());
371    }
372
373    protected virtual void PasteValuesToDataGridView() {
374      string[,] values = SplitClipboardString(Clipboard.GetText());
375      int rowIndex = 0;
376      int columnIndex = 0;
377      if (dataGridView.CurrentCell != null) {
378        rowIndex = dataGridView.CurrentCell.RowIndex;
379        columnIndex = dataGridView.CurrentCell.ColumnIndex;
380      }
381      if (Content.Rows < values.GetLength(1) + rowIndex) Content.Rows = values.GetLength(1) + rowIndex;
382      if (Content.Columns < values.GetLength(0) + columnIndex) Content.Columns = values.GetLength(0) + columnIndex;
383
384      for (int row = 0; row < values.GetLength(1); row++) {
385        for (int col = 0; col < values.GetLength(0); col++) {
386          Content.SetValue(values[col, row], row + rowIndex, col + columnIndex);
387        }
388      }
389      ClearSorting();
390    }
391    protected string[,] SplitClipboardString(string clipboardText) {
392      if (clipboardText.EndsWith(Environment.NewLine))
393        clipboardText = clipboardText.Remove(clipboardText.Length - Environment.NewLine.Length);  //remove last newline constant
394      string[,] values = null;
395      string[] lines = clipboardText.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
396      string[] cells;
397      for (int i = 0; i < lines.Length; i++) {
398        cells = lines[i].Split('\t');
399        if (values == null)
400          values = new string[cells.Length, lines.Length];
401        for (int j = 0; j < cells.Length; j++)
402          values[j, i] = string.IsNullOrEmpty(cells[j]) ? string.Empty : cells[j];
403      }
404      return values;
405    }
406
407    protected virtual void dataGridView_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e) {
408      if (Content != null) {
409        if (e.Button == MouseButtons.Left && Content.SortableView) {
410          SortColumn(e.ColumnIndex);
411        }
412      }
413    }
414
415    protected virtual void ClearSorting() {
416      virtualRowIndices = Enumerable.Range(0, Content.Rows).ToArray();
417      sortedColumnIndices.Clear();
418      UpdateSortGlyph();
419    }
420
421    protected void Sort() {
422      virtualRowIndices = Sort(sortedColumnIndices);
423      UpdateSortGlyph();
424      UpdateRowHeaders();
425      dataGridView.Invalidate();
426    }
427
428    protected virtual void SortColumn(int columnIndex) {
429      bool addToSortedIndices = (Control.ModifierKeys & Keys.Control) == Keys.Control;
430      SortOrder newSortOrder = SortOrder.Ascending;
431      if (sortedColumnIndices.Any(x => x.Key == columnIndex)) {
432        SortOrder oldSortOrder = sortedColumnIndices.Where(x => x.Key == columnIndex).First().Value;
433        int enumLength = Enum.GetValues(typeof(SortOrder)).Length;
434        newSortOrder = oldSortOrder = (SortOrder)Enum.Parse(typeof(SortOrder), ((((int)oldSortOrder) + 1) % enumLength).ToString());
435      }
436
437      if (!addToSortedIndices)
438        sortedColumnIndices.Clear();
439
440      if (sortedColumnIndices.Any(x => x.Key == columnIndex)) {
441        int sortedIndex = sortedColumnIndices.FindIndex(x => x.Key == columnIndex);
442        if (newSortOrder != SortOrder.None)
443          sortedColumnIndices[sortedIndex] = new KeyValuePair<int, SortOrder>(columnIndex, newSortOrder);
444        else
445          sortedColumnIndices.RemoveAt(sortedIndex);
446      } else
447        if (newSortOrder != SortOrder.None)
448        sortedColumnIndices.Add(new KeyValuePair<int, SortOrder>(columnIndex, newSortOrder));
449      Sort();
450    }
451
452    protected virtual int[] Sort(IEnumerable<KeyValuePair<int, SortOrder>> sortedColumns) {
453      int[] newSortedIndex = Enumerable.Range(0, Content.Rows).ToArray();
454      if (sortedColumns.Count() != 0) {
455        rowComparer.SortedIndices = sortedColumns;
456        rowComparer.Matrix = Content;
457        Array.Sort(newSortedIndex, rowComparer);
458      }
459      return newSortedIndex;
460    }
461    private void UpdateSortGlyph() {
462      foreach (DataGridViewColumn col in this.dataGridView.Columns)
463        col.HeaderCell.SortGlyphDirection = SortOrder.None;
464      foreach (KeyValuePair<int, SortOrder> p in sortedColumnIndices)
465        this.dataGridView.Columns[p.Key].HeaderCell.SortGlyphDirection = p.Value;
466    }
467    #endregion
468
469    public int GetRowIndex(int originalIndex) {
470      return virtualRowIndices[originalIndex];
471    }
472
473    public class RowComparer : IComparer<int> {
474      public RowComparer() {
475      }
476
477      private List<KeyValuePair<int, SortOrder>> sortedIndices;
478      public IEnumerable<KeyValuePair<int, SortOrder>> SortedIndices {
479        get { return this.sortedIndices; }
480        set { sortedIndices = new List<KeyValuePair<int, SortOrder>>(value); }
481      }
482      private IStringConvertibleMatrix matrix;
483      public IStringConvertibleMatrix Matrix {
484        get { return this.matrix; }
485        set { this.matrix = value; }
486      }
487
488      public int Compare(int x, int y) {
489        int result = 0;
490        double double1, double2;
491        DateTime dateTime1, dateTime2;
492        TimeSpan timeSpan1, timeSpan2;
493        string string1, string2;
494
495        if (matrix == null)
496          throw new InvalidOperationException("Could not sort IStringConvertibleMatrix if the matrix member is null.");
497        if (sortedIndices == null)
498          return 0;
499
500        foreach (KeyValuePair<int, SortOrder> pair in sortedIndices.Where(p => p.Value != SortOrder.None)) {
501          string1 = matrix.GetValue(x, pair.Key);
502          string2 = matrix.GetValue(y, pair.Key);
503          if (double.TryParse(string1, out double1) && double.TryParse(string2, out double2))
504            result = double1.CompareTo(double2);
505          else if (DateTime.TryParse(string1, out dateTime1) && DateTime.TryParse(string2, out dateTime2))
506            result = dateTime1.CompareTo(dateTime2);
507          else if (TimeSpan.TryParse(string1, out timeSpan1) && TimeSpan.TryParse(string2, out timeSpan2))
508            result = timeSpan1.CompareTo(timeSpan2);
509          else {
510            if (string1 != null)
511              result = string1.CompareTo(string2);
512            else if (string2 != null)
513              result = string2.CompareTo(string1) * -1;
514          }
515          if (pair.Value == SortOrder.Descending)
516            result *= -1;
517          if (result != 0)
518            return result;
519        }
520        return result;
521      }
522    }
523
524    protected virtual void dataGridView_MouseClick(object sender, System.Windows.Forms.MouseEventArgs e) {
525      if (Content == null) return;
526      if (e.Button == MouseButtons.Right && Content.ColumnNames.Count() != 0)
527        contextMenu.Show(MousePosition);
528    }
529    protected virtual void ShowHideColumns_Click(object sender, EventArgs e) {
530      new StringConvertibleMatrixColumnVisibilityDialog(this.dataGridView.Columns.Cast<DataGridViewColumn>()).ShowDialog();
531      columnsTextBox.Text = dataGridView.Columns.GetColumnCount(DataGridViewElementStates.Visible).ToString();
532    }
533
534    private void UpdateVisibilityOfTextBoxes() {
535      rowsTextBox.Visible = columnsTextBox.Visible = showRowsAndColumnsTextBox;
536      rowsLabel.Visible = columnsLabel.Visible = showRowsAndColumnsTextBox;
537      UpdateDataGridViewSizeAndLocation();
538    }
539
540    private void UpdateVisibilityOfStatisticalInformation() {
541      statisticsTextBox.Visible = showStatisticalInformation;
542      UpdateDataGridViewSizeAndLocation();
543    }
544
545    private void UpdateDataGridViewSizeAndLocation() {
546      int headerSize = columnsTextBox.Location.Y + columnsTextBox.Size.Height +
547       columnsTextBox.Margin.Bottom + dataGridView.Margin.Top;
548
549      int offset = showRowsAndColumnsTextBox ? headerSize : 0;
550      dataGridView.Location = new Point(0, offset);
551
552      int statisticsTextBoxHeight = showStatisticalInformation ? statisticsTextBox.Height + statisticsTextBox.Margin.Top + statisticsTextBox.Margin.Bottom : 0;
553      dataGridView.Size = new Size(Size.Width, Size.Height - offset - statisticsTextBoxHeight);
554    }
555
556    protected virtual void dataGridView_SelectionChanged(object sender, EventArgs e) {
557      statisticsTextBox.Text = string.Empty;
558      if (dataGridView.SelectedCells.Count > 1) {
559        List<double> selectedValues = new List<double>();
560        foreach (DataGridViewCell cell in dataGridView.SelectedCells) {
561          double value;
562          if (!double.TryParse(cell.Value.ToString(), out value)) return;
563          selectedValues.Add(value);
564        }
565        if (selectedValues.Count > 1) {
566          statisticsTextBox.Text = CreateStatisticsText(selectedValues);
567        }
568      }
569    }
570
571    protected virtual string CreateStatisticsText(ICollection<double> values) {
572      string stringFormat = "{0,20:0.0000}";
573      int overallCount = values.Count;
574      values = values.Where(x => !double.IsNaN(x)).ToList();
575      if (!values.Any()) {
576        return "";
577      }
578      StringBuilder statisticsText = new StringBuilder();
579      statisticsText.Append("Count: " + values.Count + "    ");
580      statisticsText.Append("Sum: " + string.Format(stringFormat, values.Sum()) + "    ");
581      statisticsText.Append("Min: " + string.Format(stringFormat, values.Min()) + "    ");
582      statisticsText.Append("Max: " + string.Format(stringFormat, values.Max()) + "    ");
583      statisticsText.Append("Average: " + string.Format(stringFormat, values.Average()) + "    ");
584      statisticsText.Append("Standard Deviation: " + string.Format(stringFormat, values.StandardDeviation()) + "    ");
585      if (overallCount > 0)
586        statisticsText.Append("Missing Values: " + string.Format(stringFormat, ((overallCount - values.Count) / (double)overallCount) * 100) + "%    ");
587      return statisticsText.ToString();
588    }
589  }
590}
Note: See TracBrowser for help on using the repository browser.