source: trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.cs @ 13570

Last change on this file since 13570 was 13570, checked in by mkommend, 5 years ago

#2568: Changed access modifiers of UpdateRow/ColumnHeader in the StringConvertibleMatrix/ArrayView to public.

File size: 23.8 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2015 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      if (Content.Columns == 0 && dataGridView.ColumnCount != Content.Columns && !Content.ReadOnly)
134        Content.Columns = dataGridView.ColumnCount;
135      else {
136        DataGridViewColumn[] columns = new DataGridViewColumn[Content.Columns];
137        for (int i = 0; i < columns.Length; ++i) {
138          var column = new DataGridViewTextBoxColumn();
139          column.FillWeight = 1;
140          columns[i] = column;
141        }
142        dataGridView.Columns.Clear();
143        dataGridView.Columns.AddRange(columns);
144      }
145
146      //DataGridViews with rows but no columns are not allowed !
147      if (Content.Rows == 0 && dataGridView.RowCount != Content.Rows && !Content.ReadOnly)
148        Content.Rows = dataGridView.RowCount;
149      else
150        dataGridView.RowCount = Content.Rows;
151
152
153      ClearSorting();
154      UpdateColumnHeaders();
155      UpdateRowHeaders();
156
157      dataGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.ColumnHeader);
158      dataGridView.AutoResizeRowHeadersWidth(DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders);
159      dataGridView.Enabled = true;
160    }
161
162    public virtual void UpdateColumnHeaders() {
163      HashSet<string> invisibleColumnNames = new HashSet<string>(dataGridView.Columns.OfType<DataGridViewColumn>()
164      .Where(c => !c.Visible && !string.IsNullOrEmpty(c.HeaderText)).Select(c => c.HeaderText));
165
166      for (int i = 0; i < dataGridView.ColumnCount; i++) {
167        if (i < Content.ColumnNames.Count())
168          dataGridView.Columns[i].HeaderText = Content.ColumnNames.ElementAt(i);
169        else
170          dataGridView.Columns[i].HeaderText = "Column " + (i + 1);
171        dataGridView.Columns[i].Visible = !invisibleColumnNames.Contains(dataGridView.Columns[i].HeaderText);
172      }
173    }
174    public virtual void UpdateRowHeaders() {
175      int index = dataGridView.FirstDisplayedScrollingRowIndex;
176      if (index == -1) index = 0;
177      int updatedRows = 0;
178      int count = dataGridView.DisplayedRowCount(true);
179
180      while (updatedRows < count) {
181        if (virtualRowIndices[index] < Content.RowNames.Count())
182          dataGridView.Rows[index].HeaderCell.Value = Content.RowNames.ElementAt(virtualRowIndices[index]);
183        else
184          dataGridView.Rows[index].HeaderCell.Value = "Row " + (index + 1);
185        if (dataGridView.Rows[index].Visible)
186          updatedRows++;
187        index++;
188      }
189    }
190
191    private void Content_RowNamesChanged(object sender, EventArgs e) {
192      if (InvokeRequired)
193        Invoke(new EventHandler(Content_RowNamesChanged), sender, e);
194      else
195        UpdateRowHeaders();
196    }
197    private void Content_ColumnNamesChanged(object sender, EventArgs e) {
198      if (InvokeRequired)
199        Invoke(new EventHandler(Content_ColumnNamesChanged), sender, e);
200      else
201        UpdateColumnHeaders();
202    }
203    private void Content_ItemChanged(object sender, EventArgs<int, int> e) {
204      if (InvokeRequired)
205        Invoke(new EventHandler<EventArgs<int, int>>(Content_ItemChanged), sender, e);
206      else
207        dataGridView.InvalidateCell(e.Value2, e.Value);
208    }
209    private void Content_Reset(object sender, EventArgs e) {
210      if (InvokeRequired)
211        Invoke(new EventHandler(Content_Reset), sender, e);
212      else
213        UpdateData();
214    }
215
216    #region TextBox Events
217    private void rowsTextBox_Validating(object sender, CancelEventArgs e) {
218      if (ReadOnly || Locked)
219        return;
220      int i = 0;
221      if (!int.TryParse(rowsTextBox.Text, out i) || (i <= 0)) {
222        e.Cancel = true;
223        errorProvider.SetError(rowsTextBox, "Invalid Number of Rows (Valid values are positive integers larger than 0)");
224        rowsTextBox.SelectAll();
225      }
226    }
227    private void rowsTextBox_Validated(object sender, EventArgs e) {
228      if (!Content.ReadOnly) Content.Rows = int.Parse(rowsTextBox.Text);
229      errorProvider.SetError(rowsTextBox, string.Empty);
230    }
231    private void rowsTextBox_KeyDown(object sender, KeyEventArgs e) {
232      if (e.KeyCode == Keys.Enter || e.KeyCode == Keys.Return)
233        rowsLabel.Focus();  // set focus on label to validate data
234      if (e.KeyCode == Keys.Escape) {
235        rowsTextBox.Text = Content.Rows.ToString();
236        rowsLabel.Focus();  // set focus on label to validate data
237      }
238    }
239    private void columnsTextBox_Validating(object sender, CancelEventArgs e) {
240      if (ReadOnly || Locked)
241        return;
242      int i = 0;
243      if (!int.TryParse(columnsTextBox.Text, out i) || (i <= 0)) {
244        e.Cancel = true;
245        errorProvider.SetError(columnsTextBox, "Invalid Number of Columns (Valid values are positive integers larger than 0)");
246        columnsTextBox.SelectAll();
247      }
248    }
249    private void columnsTextBox_Validated(object sender, EventArgs e) {
250      if (!Content.ReadOnly) Content.Columns = int.Parse(columnsTextBox.Text);
251      errorProvider.SetError(columnsTextBox, string.Empty);
252    }
253    private void columnsTextBox_KeyDown(object sender, KeyEventArgs e) {
254      if (e.KeyCode == Keys.Enter || e.KeyCode == Keys.Return)
255        columnsLabel.Focus();  // set focus on label to validate data
256      if (e.KeyCode == Keys.Escape) {
257        columnsTextBox.Text = Content.Columns.ToString();
258        columnsLabel.Focus();  // set focus on label to validate data
259      }
260    }
261    #endregion
262
263    #region DataGridView Events
264    protected virtual void dataGridView_CellValidating(object sender, DataGridViewCellValidatingEventArgs e) {
265      if (!dataGridView.ReadOnly) {
266        string errorMessage;
267        if (Content != null && !Content.Validate(e.FormattedValue.ToString(), out errorMessage)) {
268          e.Cancel = true;
269          dataGridView.Rows[e.RowIndex].ErrorText = errorMessage;
270        }
271      }
272    }
273    protected virtual void dataGridView_CellParsing(object sender, DataGridViewCellParsingEventArgs e) {
274      if (!dataGridView.ReadOnly) {
275        string value = e.Value.ToString();
276        int rowIndex = virtualRowIndices[e.RowIndex];
277        e.ParsingApplied = Content.SetValue(value, rowIndex, e.ColumnIndex);
278        if (e.ParsingApplied) e.Value = Content.GetValue(rowIndex, e.ColumnIndex);
279      }
280    }
281    private void dataGridView_CellEndEdit(object sender, DataGridViewCellEventArgs e) {
282      dataGridView.Rows[e.RowIndex].ErrorText = string.Empty;
283    }
284    protected virtual void dataGridView_CellValueNeeded(object sender, DataGridViewCellValueEventArgs e) {
285      if (Content != null && e.RowIndex < Content.Rows && e.ColumnIndex < Content.Columns) {
286        int rowIndex = virtualRowIndices[e.RowIndex];
287        e.Value = Content.GetValue(rowIndex, e.ColumnIndex);
288      }
289    }
290
291    private void dataGridView_Scroll(object sender, System.Windows.Forms.ScrollEventArgs e) {
292      this.UpdateRowHeaders();
293    }
294    private void dataGridView_Resize(object sender, EventArgs e) {
295      this.UpdateRowHeaders();
296    }
297
298    protected virtual void dataGridView_KeyDown(object sender, KeyEventArgs e) {
299      if (!ReadOnly && e.Control && e.KeyCode == Keys.V)
300        PasteValuesToDataGridView();
301      else if (e.Control && e.KeyCode == Keys.C)
302        CopyValuesFromDataGridView();
303    }
304
305    private void CopyValuesFromDataGridView() {
306      if (dataGridView.SelectedCells.Count == 0) return;
307      StringBuilder s = new StringBuilder();
308      int minRowIndex = dataGridView.SelectedCells[0].RowIndex;
309      int maxRowIndex = dataGridView.SelectedCells[dataGridView.SelectedCells.Count - 1].RowIndex;
310      int minColIndex = dataGridView.SelectedCells[0].ColumnIndex;
311      int maxColIndex = dataGridView.SelectedCells[dataGridView.SelectedCells.Count - 1].ColumnIndex;
312
313      if (minRowIndex > maxRowIndex) {
314        int temp = minRowIndex;
315        minRowIndex = maxRowIndex;
316        maxRowIndex = temp;
317      }
318      if (minColIndex > maxColIndex) {
319        int temp = minColIndex;
320        minColIndex = maxColIndex;
321        maxColIndex = temp;
322      }
323
324      bool addRowNames = dataGridView.AreAllCellsSelected(false) && Content.RowNames.Count() > 0;
325      bool addColumnNames = dataGridView.AreAllCellsSelected(false) && Content.ColumnNames.Count() > 0;
326
327      //add colum names
328      if (addColumnNames) {
329        if (addRowNames)
330          s.Append('\t');
331
332        DataGridViewColumn column = dataGridView.Columns.GetFirstColumn(DataGridViewElementStates.Visible);
333        while (column != null) {
334          s.Append(column.HeaderText);
335          s.Append('\t');
336          column = dataGridView.Columns.GetNextColumn(column, DataGridViewElementStates.Visible, DataGridViewElementStates.None);
337        }
338        s.Remove(s.Length - 1, 1); //remove last tab
339        s.Append(Environment.NewLine);
340      }
341
342      for (int i = minRowIndex; i <= maxRowIndex; i++) {
343        if (!dataGridView.Rows[i].Visible) continue;
344
345        int rowIndex = this.virtualRowIndices[i];
346        if (addRowNames) {
347          s.Append(Content.RowNames.ElementAt(rowIndex));
348          s.Append('\t');
349        }
350
351        DataGridViewColumn column = dataGridView.Columns.GetFirstColumn(DataGridViewElementStates.Visible);
352        while (column != null) {
353          DataGridViewCell cell = dataGridView[column.Index, i];
354          if (cell.Selected) {
355            s.Append(Content.GetValue(rowIndex, column.Index));
356            s.Append('\t');
357          }
358
359          column = dataGridView.Columns.GetNextColumn(column, DataGridViewElementStates.Visible, DataGridViewElementStates.None);
360        }
361        s.Remove(s.Length - 1, 1); //remove last tab
362        s.Append(Environment.NewLine);
363      }
364      Clipboard.SetText(s.ToString());
365    }
366
367    protected virtual void PasteValuesToDataGridView() {
368      string[,] values = SplitClipboardString(Clipboard.GetText());
369      int rowIndex = 0;
370      int columnIndex = 0;
371      if (dataGridView.CurrentCell != null) {
372        rowIndex = dataGridView.CurrentCell.RowIndex;
373        columnIndex = dataGridView.CurrentCell.ColumnIndex;
374      }
375      if (Content.Rows < values.GetLength(1) + rowIndex) Content.Rows = values.GetLength(1) + rowIndex;
376      if (Content.Columns < values.GetLength(0) + columnIndex) Content.Columns = values.GetLength(0) + columnIndex;
377
378      for (int row = 0; row < values.GetLength(1); row++) {
379        for (int col = 0; col < values.GetLength(0); col++) {
380          Content.SetValue(values[col, row], row + rowIndex, col + columnIndex);
381        }
382      }
383      ClearSorting();
384    }
385    protected string[,] SplitClipboardString(string clipboardText) {
386      if (clipboardText.EndsWith(Environment.NewLine))
387        clipboardText = clipboardText.Remove(clipboardText.Length - Environment.NewLine.Length);  //remove last newline constant
388      string[,] values = null;
389      string[] lines = clipboardText.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
390      string[] cells;
391      for (int i = 0; i < lines.Length; i++) {
392        cells = lines[i].Split('\t');
393        if (values == null)
394          values = new string[cells.Length, lines.Length];
395        for (int j = 0; j < cells.Length; j++)
396          values[j, i] = string.IsNullOrEmpty(cells[j]) ? string.Empty : cells[j];
397      }
398      return values;
399    }
400
401    protected virtual void dataGridView_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e) {
402      if (Content != null) {
403        if (e.Button == MouseButtons.Left && Content.SortableView) {
404          SortColumn(e.ColumnIndex);
405        }
406      }
407    }
408
409    protected virtual void ClearSorting() {
410      virtualRowIndices = Enumerable.Range(0, Content.Rows).ToArray();
411      sortedColumnIndices.Clear();
412      UpdateSortGlyph();
413    }
414
415    protected void Sort() {
416      virtualRowIndices = Sort(sortedColumnIndices);
417      UpdateSortGlyph();
418      UpdateRowHeaders();
419      dataGridView.Invalidate();
420    }
421
422    protected virtual void SortColumn(int columnIndex) {
423      bool addToSortedIndices = (Control.ModifierKeys & Keys.Control) == Keys.Control;
424      SortOrder newSortOrder = SortOrder.Ascending;
425      if (sortedColumnIndices.Any(x => x.Key == columnIndex)) {
426        SortOrder oldSortOrder = sortedColumnIndices.Where(x => x.Key == columnIndex).First().Value;
427        int enumLength = Enum.GetValues(typeof(SortOrder)).Length;
428        newSortOrder = oldSortOrder = (SortOrder)Enum.Parse(typeof(SortOrder), ((((int)oldSortOrder) + 1) % enumLength).ToString());
429      }
430
431      if (!addToSortedIndices)
432        sortedColumnIndices.Clear();
433
434      if (sortedColumnIndices.Any(x => x.Key == columnIndex)) {
435        int sortedIndex = sortedColumnIndices.FindIndex(x => x.Key == columnIndex);
436        if (newSortOrder != SortOrder.None)
437          sortedColumnIndices[sortedIndex] = new KeyValuePair<int, SortOrder>(columnIndex, newSortOrder);
438        else
439          sortedColumnIndices.RemoveAt(sortedIndex);
440      } else
441        if (newSortOrder != SortOrder.None)
442          sortedColumnIndices.Add(new KeyValuePair<int, SortOrder>(columnIndex, newSortOrder));
443      Sort();
444    }
445
446    protected virtual int[] Sort(IEnumerable<KeyValuePair<int, SortOrder>> sortedColumns) {
447      int[] newSortedIndex = Enumerable.Range(0, Content.Rows).ToArray();
448      if (sortedColumns.Count() != 0) {
449        rowComparer.SortedIndices = sortedColumns;
450        rowComparer.Matrix = Content;
451        Array.Sort(newSortedIndex, rowComparer);
452      }
453      return newSortedIndex;
454    }
455    private void UpdateSortGlyph() {
456      foreach (DataGridViewColumn col in this.dataGridView.Columns)
457        col.HeaderCell.SortGlyphDirection = SortOrder.None;
458      foreach (KeyValuePair<int, SortOrder> p in sortedColumnIndices)
459        this.dataGridView.Columns[p.Key].HeaderCell.SortGlyphDirection = p.Value;
460    }
461    #endregion
462
463    public int GetRowIndex(int originalIndex) {
464      return virtualRowIndices[originalIndex];
465    }
466
467    public class RowComparer : IComparer<int> {
468      public RowComparer() {
469      }
470
471      private List<KeyValuePair<int, SortOrder>> sortedIndices;
472      public IEnumerable<KeyValuePair<int, SortOrder>> SortedIndices {
473        get { return this.sortedIndices; }
474        set { sortedIndices = new List<KeyValuePair<int, SortOrder>>(value); }
475      }
476      private IStringConvertibleMatrix matrix;
477      public IStringConvertibleMatrix Matrix {
478        get { return this.matrix; }
479        set { this.matrix = value; }
480      }
481
482      public int Compare(int x, int y) {
483        int result = 0;
484        double double1, double2;
485        DateTime dateTime1, dateTime2;
486        TimeSpan timeSpan1, timeSpan2;
487        string string1, string2;
488
489        if (matrix == null)
490          throw new InvalidOperationException("Could not sort IStringConvertibleMatrix if the matrix member is null.");
491        if (sortedIndices == null)
492          return 0;
493
494        foreach (KeyValuePair<int, SortOrder> pair in sortedIndices.Where(p => p.Value != SortOrder.None)) {
495          string1 = matrix.GetValue(x, pair.Key);
496          string2 = matrix.GetValue(y, pair.Key);
497          if (double.TryParse(string1, out double1) && double.TryParse(string2, out double2))
498            result = double1.CompareTo(double2);
499          else if (DateTime.TryParse(string1, out dateTime1) && DateTime.TryParse(string2, out dateTime2))
500            result = dateTime1.CompareTo(dateTime2);
501          else if (TimeSpan.TryParse(string1, out timeSpan1) && TimeSpan.TryParse(string2, out timeSpan2))
502            result = timeSpan1.CompareTo(timeSpan2);
503          else {
504            if (string1 != null)
505              result = string1.CompareTo(string2);
506            else if (string2 != null)
507              result = string2.CompareTo(string1) * -1;
508          }
509          if (pair.Value == SortOrder.Descending)
510            result *= -1;
511          if (result != 0)
512            return result;
513        }
514        return result;
515      }
516    }
517
518    protected virtual void dataGridView_MouseClick(object sender, System.Windows.Forms.MouseEventArgs e) {
519      if (Content == null) return;
520      if (e.Button == MouseButtons.Right && Content.ColumnNames.Count() != 0)
521        contextMenu.Show(MousePosition);
522    }
523    protected virtual void ShowHideColumns_Click(object sender, EventArgs e) {
524      new StringConvertibleMatrixColumnVisibilityDialog(this.dataGridView.Columns.Cast<DataGridViewColumn>()).ShowDialog();
525      columnsTextBox.Text = dataGridView.Columns.GetColumnCount(DataGridViewElementStates.Visible).ToString();
526    }
527
528    private void UpdateVisibilityOfTextBoxes() {
529      rowsTextBox.Visible = columnsTextBox.Visible = showRowsAndColumnsTextBox;
530      rowsLabel.Visible = columnsLabel.Visible = showRowsAndColumnsTextBox;
531      UpdateDataGridViewSizeAndLocation();
532    }
533
534    private void UpdateVisibilityOfStatisticalInformation() {
535      statisticsTextBox.Visible = showStatisticalInformation;
536      UpdateDataGridViewSizeAndLocation();
537    }
538
539    private void UpdateDataGridViewSizeAndLocation() {
540      int headerSize = columnsTextBox.Location.Y + columnsTextBox.Size.Height +
541       columnsTextBox.Margin.Bottom + dataGridView.Margin.Top;
542
543      int offset = showRowsAndColumnsTextBox ? headerSize : 0;
544      dataGridView.Location = new Point(0, offset);
545
546      int statisticsTextBoxHeight = showStatisticalInformation ? statisticsTextBox.Height + statisticsTextBox.Margin.Top + statisticsTextBox.Margin.Bottom : 0;
547      dataGridView.Size = new Size(Size.Width, Size.Height - offset - statisticsTextBoxHeight);
548    }
549
550    protected virtual void dataGridView_SelectionChanged(object sender, EventArgs e) {
551      statisticsTextBox.Text = string.Empty;
552      if (dataGridView.SelectedCells.Count > 1) {
553        List<double> selectedValues = new List<double>();
554        foreach (DataGridViewCell cell in dataGridView.SelectedCells) {
555          double value;
556          if (!double.TryParse(cell.Value.ToString(), out value)) return;
557          selectedValues.Add(value);
558        }
559        if (selectedValues.Count > 1) {
560          statisticsTextBox.Text = CreateStatisticsText(selectedValues);
561        }
562      }
563    }
564
565    protected virtual string CreateStatisticsText(ICollection<double> values) {
566      string stringFormat = "{0,20:0.0000}";
567      int overallCount = values.Count;
568      values = values.Where(x => !double.IsNaN(x)).ToList();
569      if (!values.Any()) {
570        return "";
571      }
572      StringBuilder statisticsText = new StringBuilder();
573      statisticsText.Append("Count: " + values.Count + "    ");
574      statisticsText.Append("Sum: " + string.Format(stringFormat, values.Sum()) + "    ");
575      statisticsText.Append("Min: " + string.Format(stringFormat, values.Min()) + "    ");
576      statisticsText.Append("Max: " + string.Format(stringFormat, values.Max()) + "    ");
577      statisticsText.Append("Average: " + string.Format(stringFormat, values.Average()) + "    ");
578      statisticsText.Append("Standard Deviation: " + string.Format(stringFormat, values.StandardDeviation()) + "    ");
579      if (overallCount > 0)
580        statisticsText.Append("Missing Values: " + string.Format(stringFormat, ((overallCount - values.Count) / (double)overallCount) * 100) + "%    ");
581      return statisticsText.ToString();
582    }
583  }
584}
Note: See TracBrowser for help on using the repository browser.