Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionBubbleChartView.cs @ 5924

Last change on this file since 5924 was 5837, checked in by swagner, 14 years ago

Implemented review comments of mkommend (#1112)

File size: 28.6 KB
RevLine 
[3349]1#region License Information
2/* HeuristicLab
[5445]3 * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
[3349]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.Drawing;
25using System.Linq;
26using System.Windows.Forms;
27using System.Windows.Forms.DataVisualization.Charting;
[3376]28using HeuristicLab.Common;
[3349]29using HeuristicLab.Core;
[3447]30using HeuristicLab.Data;
[4068]31using HeuristicLab.MainForm;
32using HeuristicLab.MainForm.WindowsForms;
[3349]33
34namespace HeuristicLab.Optimization.Views {
35  [View("RunCollection BubbleChart")]
36  [Content(typeof(RunCollection), false)]
37  public partial class RunCollectionBubbleChartView : AsynchronousContentView {
[3524]38    private enum SizeDimension { Constant = 0 }
39    private enum AxisDimension { Index = 0 }
40
[3726]41    private string xAxisValue;
42    private string yAxisValue;
43    private string sizeAxisValue;
44
[4883]45    private Dictionary<IRun, List<DataPoint>> runToDataPointMapping;
[3349]46    private Dictionary<int, Dictionary<object, double>> categoricalMapping;
[3411]47    private Dictionary<IRun, double> xJitter;
48    private Dictionary<IRun, double> yJitter;
49    private double xJitterFactor = 0.0;
50    private double yJitterFactor = 0.0;
51    private Random random;
52    private bool isSelecting = false;
[4883]53    private bool suppressUpdates = false;
[3349]54
55    public RunCollectionBubbleChartView() {
56      InitializeComponent();
[4846]57      chart.ContextMenuStrip.Items.Insert(0, openBoxPlotViewToolStripMenuItem);
[3411]58
[4883]59      runToDataPointMapping = new Dictionary<IRun, List<DataPoint>>();
[4635]60      categoricalMapping = new Dictionary<int, Dictionary<object, double>>();
61      xJitter = new Dictionary<IRun, double>();
62      yJitter = new Dictionary<IRun, double>();
63      random = new Random();
[4846]64
[4635]65      colorDialog.Color = Color.Black;
66      colorButton.Image = this.GenerateImage(16, 16, this.colorDialog.Color);
67      isSelecting = false;
[4846]68
[4636]69      chart.CustomizeAllChartAreas();
[4635]70      chart.ChartAreas[0].CursorX.Interval = 1;
71      chart.ChartAreas[0].CursorY.Interval = 1;
72      chart.ChartAreas[0].AxisX.ScaleView.Zoomable = !this.isSelecting;
73      chart.ChartAreas[0].AxisY.ScaleView.Zoomable = !this.isSelecting;
[3349]74    }
75
76    public new RunCollection Content {
77      get { return (RunCollection)base.Content; }
78      set { base.Content = value; }
79    }
[3447]80    public IStringConvertibleMatrix Matrix {
81      get { return this.Content; }
82    }
83
[3349]84    protected override void RegisterContentEvents() {
85      base.RegisterContentEvents();
86      Content.Reset += new EventHandler(Content_Reset);
87      Content.ColumnNamesChanged += new EventHandler(Content_ColumnNamesChanged);
[3428]88      Content.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IRun>(Content_ItemsAdded);
89      Content.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IRun>(Content_ItemsRemoved);
90      Content.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IRun>(Content_CollectionReset);
[4888]91      Content.UpdateOfRunsInProgressChanged += new EventHandler(Content_UpdateOfRunsInProgressChanged);
[3448]92      RegisterRunEvents(Content);
93    }
[3349]94    protected override void DeregisterContentEvents() {
95      base.DeregisterContentEvents();
96      Content.Reset -= new EventHandler(Content_Reset);
97      Content.ColumnNamesChanged -= new EventHandler(Content_ColumnNamesChanged);
[3428]98      Content.ItemsAdded -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IRun>(Content_ItemsAdded);
99      Content.ItemsRemoved -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IRun>(Content_ItemsRemoved);
100      Content.CollectionReset -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IRun>(Content_CollectionReset);
[4888]101      Content.UpdateOfRunsInProgressChanged -= new EventHandler(Content_UpdateOfRunsInProgressChanged);
[3448]102      DeregisterRunEvents(Content);
103    }
[4094]104    protected virtual void RegisterRunEvents(IEnumerable<IRun> runs) {
105      foreach (IRun run in runs)
106        run.Changed += new EventHandler(run_Changed);
107    }
[3448]108    protected virtual void DeregisterRunEvents(IEnumerable<IRun> runs) {
109      foreach (IRun run in runs)
[3428]110        run.Changed -= new EventHandler(run_Changed);
[3349]111    }
[3428]112
113    private void Content_CollectionReset(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<IRun> e) {
[3448]114      DeregisterRunEvents(e.OldItems);
115      RegisterRunEvents(e.Items);
[3428]116    }
117    private void Content_ItemsRemoved(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<IRun> e) {
[3449]118      DeregisterRunEvents(e.Items);
[3428]119    }
120    private void Content_ItemsAdded(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<IRun> e) {
[3448]121      RegisterRunEvents(e.Items);
[3428]122    }
123    private void run_Changed(object sender, EventArgs e) {
[3632]124      if (InvokeRequired)
125        this.Invoke(new EventHandler(run_Changed), sender, e);
126      else {
127        IRun run = (IRun)sender;
128        UpdateRun(run);
129      }
[3614]130    }
131
132    private void UpdateRun(IRun run) {
[4883]133      if (!suppressUpdates) {
134        if (runToDataPointMapping.ContainsKey(run)) {
135          foreach (DataPoint point in runToDataPointMapping[run]) {
136            point.Color = run.Color;
137            if (!run.Visible) {
138              this.chart.Series[0].Points.Remove(point);
139              UpdateCursorInterval();
140              chart.ChartAreas[0].RecalculateAxesScale();
141            }
142          }
143          if (!run.Visible) runToDataPointMapping.Remove(run);
144        } else {
145          AddDataPoint(run);
[4799]146          UpdateCursorInterval();
147          chart.ChartAreas[0].RecalculateAxesScale();
148        }
[4883]149
150        if (this.chart.Series[0].Points.Count == 0)
151          noRunsLabel.Visible = true;
152        else
153          noRunsLabel.Visible = false;
[4799]154      }
[3428]155    }
156
[3349]157    protected override void OnContentChanged() {
158      base.OnContentChanged();
[3411]159      this.categoricalMapping.Clear();
[3499]160      UpdateComboBoxes();
161      UpdateDataPoints();
[3349]162    }
163    private void Content_ColumnNamesChanged(object sender, EventArgs e) {
164      if (InvokeRequired)
165        Invoke(new EventHandler(Content_ColumnNamesChanged), sender, e);
166      else
167        UpdateComboBoxes();
168    }
169
170    private void UpdateComboBoxes() {
[3701]171      string selectedXAxis = (string)this.xAxisComboBox.SelectedItem;
172      string selectedYAxis = (string)this.yAxisComboBox.SelectedItem;
173      string selectedSizeAxis = (string)this.sizeComboBox.SelectedItem;
[3349]174      this.xAxisComboBox.Items.Clear();
175      this.yAxisComboBox.Items.Clear();
[3411]176      this.sizeComboBox.Items.Clear();
[3499]177      if (Content != null) {
[3524]178        string[] additionalAxisDimension = Enum.GetNames(typeof(AxisDimension));
179        this.xAxisComboBox.Items.AddRange(additionalAxisDimension);
[3499]180        this.xAxisComboBox.Items.AddRange(Matrix.ColumnNames.ToArray());
[3524]181        this.yAxisComboBox.Items.AddRange(additionalAxisDimension);
[3499]182        this.yAxisComboBox.Items.AddRange(Matrix.ColumnNames.ToArray());
[3524]183        string[] additionalSizeDimension = Enum.GetNames(typeof(SizeDimension));
184        this.sizeComboBox.Items.AddRange(additionalSizeDimension);
[3499]185        this.sizeComboBox.Items.AddRange(Matrix.ColumnNames.ToArray());
[3524]186        this.sizeComboBox.SelectedItem = SizeDimension.Constant.ToString();
[3701]187
188        bool changed = false;
189        if (selectedXAxis != null && xAxisComboBox.Items.Contains(selectedXAxis)) {
190          xAxisComboBox.SelectedItem = selectedXAxis;
191          changed = true;
192        }
193        if (selectedYAxis != null && yAxisComboBox.Items.Contains(selectedYAxis)) {
194          yAxisComboBox.SelectedItem = selectedYAxis;
195          changed = true;
196        }
197        if (selectedSizeAxis != null && sizeComboBox.Items.Contains(selectedSizeAxis)) {
198          sizeComboBox.SelectedItem = selectedSizeAxis;
199          changed = true;
200        }
201        if (changed)
202          UpdateDataPoints();
[3499]203      }
[3349]204    }
205
[4883]206
[4888]207    private void Content_UpdateOfRunsInProgressChanged(object sender, EventArgs e) {
[4883]208      if (InvokeRequired)
[4888]209        Invoke(new EventHandler(Content_UpdateOfRunsInProgressChanged), sender, e);
[4883]210      else {
[4888]211        suppressUpdates = Content.UpdateOfRunsInProgress;
[4883]212        if (!suppressUpdates) UpdateDataPoints();
213      }
214    }
215
[3349]216    private void Content_Reset(object sender, EventArgs e) {
217      if (InvokeRequired)
218        Invoke(new EventHandler(Content_Reset), sender, e);
219      else {
220        this.categoricalMapping.Clear();
221        UpdateDataPoints();
222      }
223    }
224
225    private void UpdateDataPoints() {
226      Series series = this.chart.Series[0];
227      series.Points.Clear();
[4799]228      runToDataPointMapping.Clear();
[3499]229      if (Content != null) {
230        foreach (IRun run in this.Content)
231          this.AddDataPoint(run);
[3543]232
233        if (this.chart.Series[0].Points.Count == 0)
234          noRunsLabel.Visible = true;
[4209]235        else {
[3543]236          noRunsLabel.Visible = false;
[5330]237          UpdateMarkerSizes();
[4209]238          UpdateCursorInterval();
239        }
[3499]240      }
[5824]241      var xAxis = chart.ChartAreas[0].AxisX;
242      var yAxis = chart.ChartAreas[0].AxisY;
243      xTrackBar.Value = 0;
244      yTrackBar.Value = 0;
245      SetAutomaticUpdateOfAxis(xAxis, true);
246      SetAutomaticUpdateOfAxis(yAxis, true);
[3428]247    }
[5330]248
249    private void UpdateMarkerSizes() {
250      double[] sizeValues = this.chart.Series[0].Points.Select(p => p.YValues[1]).ToArray();
251      double minSizeValue = sizeValues.Min();
252      double maxSizeValue = sizeValues.Max();
253
254      for (int i = 0; i < sizeValues.Length; i++) {
255        DataPoint point = this.chart.Series[0].Points[i];
[5348]256        double sizeRange = maxSizeValue - minSizeValue;
257        double relativeSize = (point.YValues[1] - minSizeValue);
258
259        if (sizeRange > double.Epsilon) relativeSize /= sizeRange;
260        else relativeSize = 1;
261
[5330]262        point.MarkerSize = (int)Math.Round((sizeTrackBar.Value - sizeTrackBar.Minimum) * relativeSize + sizeTrackBar.Minimum);
263      }
264    }
265
[5824]266    private void UpdateDataPointJitter() {
267      var xAxis = this.chart.ChartAreas[0].AxisX;
268      var yAxis = this.chart.ChartAreas[0].AxisY;
269      SetAutomaticUpdateOfAxis(xAxis, false);
270      SetAutomaticUpdateOfAxis(yAxis, false);
271
272      foreach (DataPoint point in chart.Series[0].Points) {
273        IRun run = (IRun)point.Tag;
274        double xValue = GetValue(run, xAxisValue).Value;
275        double yValue = GetValue(run, yAxisValue).Value;
276
277        if (!xJitterFactor.IsAlmost(0.0))
278          xValue += 0.1 * GetXJitter(run) * xJitterFactor * (xAxis.Maximum - xAxis.Minimum);
279        if (!yJitterFactor.IsAlmost(0.0))
280          yValue += 0.1 * GetYJitter(run) * yJitterFactor * (yAxis.Maximum - yAxis.Minimum);
281
282        point.XValue = xValue;
283        point.YValues[0] = yValue;
284      }
285    }
286
287    private void SetAutomaticUpdateOfAxis(Axis axis, bool enabled) {
288      if (enabled) {
289        axis.Maximum = double.NaN;
290        axis.Minimum = double.NaN;
291        axis.MajorGrid.Interval = double.NaN;
292        axis.MajorTickMark.Interval = double.NaN;
293        axis.LabelStyle.Interval = double.NaN;
294      } else {
295        axis.Minimum = axis.Minimum;
296        axis.Maximum = axis.Maximum;
297        axis.MajorGrid.Interval = axis.MajorGrid.Interval;
298        axis.MajorTickMark.Interval = axis.MajorTickMark.Interval;
299        axis.LabelStyle.Interval = axis.LabelStyle.Interval;
300      }
301
302    }
303
[3428]304    private void AddDataPoint(IRun run) {
[3349]305      double? xValue;
306      double? yValue;
[3411]307      double? sizeValue;
[3428]308      Series series = this.chart.Series[0];
[3726]309
[4845]310      xValue = GetValue(run, xAxisValue);
311      yValue = GetValue(run, yAxisValue);
312      sizeValue = GetValue(run, sizeAxisValue);
[3726]313
[3543]314      if (xValue.HasValue && yValue.HasValue && sizeValue.HasValue) {
[3701]315        xValue = xValue.Value;
[5824]316
[3701]317        yValue = yValue.Value;
[5824]318
[3428]319        if (run.Visible) {
[3411]320          DataPoint point = new DataPoint(xValue.Value, new double[] { yValue.Value, sizeValue.Value });
[3428]321          point.Tag = run;
322          point.Color = run.Color;
[3411]323          series.Points.Add(point);
[4883]324          if (!runToDataPointMapping.ContainsKey(run)) runToDataPointMapping.Add(run, new List<DataPoint>());
325          runToDataPointMapping[run].Add(point);
[3411]326        }
[3349]327      }
328    }
[3524]329    private double? GetValue(IRun run, string columnName) {
330      if (run == null || string.IsNullOrEmpty(columnName))
[3349]331        return null;
332
[3524]333      if (Enum.IsDefined(typeof(AxisDimension), columnName)) {
334        AxisDimension axisDimension = (AxisDimension)Enum.Parse(typeof(AxisDimension), columnName);
335        return GetValue(run, axisDimension);
336      } else if (Enum.IsDefined(typeof(SizeDimension), columnName)) {
337        SizeDimension sizeDimension = (SizeDimension)Enum.Parse(typeof(SizeDimension), columnName);
338        return GetValue(run, sizeDimension);
339      } else {
340        int columnIndex = Matrix.ColumnNames.ToList().IndexOf(columnName);
341        IItem value = Content.GetValue(run, columnIndex);
342        if (value == null)
343          return null;
[3447]344
[3524]345        DoubleValue doubleValue = value as DoubleValue;
346        IntValue intValue = value as IntValue;
[4049]347        TimeSpanValue timeSpanValue = value as TimeSpanValue;
[3543]348        double? ret = null;
349        if (doubleValue != null) {
350          if (!double.IsNaN(doubleValue.Value) && !double.IsInfinity(doubleValue.Value))
351            ret = doubleValue.Value;
352        } else if (intValue != null)
[3524]353          ret = intValue.Value;
[4049]354        else if (timeSpanValue != null) {
355          ret = timeSpanValue.Value.TotalSeconds;
356        } else
[3524]357          ret = GetCategoricalValue(columnIndex, value.ToString());
[3447]358
[3524]359        return ret;
360      }
[3349]361    }
[3524]362    private double GetCategoricalValue(int dimension, string value) {
[3349]363      if (!this.categoricalMapping.ContainsKey(dimension))
364        this.categoricalMapping[dimension] = new Dictionary<object, double>();
[3524]365      if (!this.categoricalMapping[dimension].ContainsKey(value)) {
[3349]366        if (this.categoricalMapping[dimension].Values.Count == 0)
[3524]367          this.categoricalMapping[dimension][value] = 1.0;
[3349]368        else
[3524]369          this.categoricalMapping[dimension][value] = this.categoricalMapping[dimension].Values.Max() + 1.0;
[3349]370      }
[3524]371      return this.categoricalMapping[dimension][value];
[3349]372    }
[3524]373    private double GetValue(IRun run, AxisDimension axisDimension) {
374      double value = double.NaN;
375      switch (axisDimension) {
376        case AxisDimension.Index: {
377            value = Content.ToList().IndexOf(run);
378            break;
379          }
380        default: {
381            throw new ArgumentException("No handling strategy for " + axisDimension.ToString() + " is defined.");
382          }
383      }
384      return value;
385    }
386    private double GetValue(IRun run, SizeDimension sizeDimension) {
387      double value = double.NaN;
388      switch (sizeDimension) {
389        case SizeDimension.Constant: {
390            value = 2;
391            break;
392          }
393        default: {
394            throw new ArgumentException("No handling strategy for " + sizeDimension.ToString() + " is defined.");
395          }
396      }
397      return value;
398    }
[3707]399    private void UpdateCursorInterval() {
400      Series series = chart.Series[0];
401      double[] xValues = (from point in series.Points
402                          where !point.IsEmpty
403                          select point.XValue)
404                    .DefaultIfEmpty(1.0)
405                    .ToArray();
406      double[] yValues = (from point in series.Points
407                          where !point.IsEmpty
408                          select point.YValues[0])
409                    .DefaultIfEmpty(1.0)
410                    .ToArray();
[3349]411
[3707]412      double xRange = xValues.Max() - xValues.Min();
413      double yRange = yValues.Max() - yValues.Min();
[4049]414      if (xRange.IsAlmost(0.0)) xRange = 1.0;
415      if (yRange.IsAlmost(0.0)) yRange = 1.0;
[3707]416      double xDigits = (int)Math.Log10(xRange) - 3;
417      double yDigits = (int)Math.Log10(yRange) - 3;
418      double xZoomInterval = Math.Pow(10, xDigits);
419      double yZoomInterval = Math.Pow(10, yDigits);
420      this.chart.ChartAreas[0].CursorX.Interval = xZoomInterval;
421      this.chart.ChartAreas[0].CursorY.Interval = yZoomInterval;
[4049]422
423      //code to handle TimeSpanValues correct
424      int axisDimensionCount = Enum.GetNames(typeof(AxisDimension)).Count();
425      int columnIndex = xAxisComboBox.SelectedIndex - axisDimensionCount;
426      if (columnIndex >= 0 && Content.GetValue(0, columnIndex) is TimeSpanValue)
427        this.chart.ChartAreas[0].CursorX.Interval = 1;
428      columnIndex = yAxisComboBox.SelectedIndex - axisDimensionCount;
429      if (columnIndex >= 0 && Content.GetValue(0, columnIndex) is TimeSpanValue)
430        this.chart.ChartAreas[0].CursorY.Interval = 1;
[3707]431    }
432
[4888]433    #region Drag & drop and tooltip
[3411]434    private IRun draggedRun;
435    private void chart_MouseDown(object sender, MouseEventArgs e) {
436      HitTestResult h = this.chart.HitTest(e.X, e.Y);
437      if (h.ChartElementType == ChartElementType.DataPoint) {
[3459]438        IRun run = (IRun)((DataPoint)h.Object).Tag;
[3428]439        if (e.Clicks >= 2) {
[3557]440          IContentView view = MainFormManager.MainForm.ShowContent(run);
441          if (view != null) {
442            view.ReadOnly = this.ReadOnly;
443            view.Locked = this.Locked;
444          }
[3546]445        } else
[3428]446          this.draggedRun = run;
[3546]447        this.chart.ChartAreas[0].CursorX.SetSelectionPosition(double.NaN, double.NaN);
448        this.chart.ChartAreas[0].CursorY.SetSelectionPosition(double.NaN, double.NaN);
[3411]449      }
450    }
451
[3428]452    private void chart_MouseUp(object sender, MouseEventArgs e) {
[3459]453      if (isSelecting) {
[4888]454        Content.UpdateOfRunsInProgress = true;
[3459]455        System.Windows.Forms.DataVisualization.Charting.Cursor xCursor = chart.ChartAreas[0].CursorX;
456        System.Windows.Forms.DataVisualization.Charting.Cursor yCursor = chart.ChartAreas[0].CursorY;
[3428]457
[3459]458        double minX = Math.Min(xCursor.SelectionStart, xCursor.SelectionEnd);
459        double maxX = Math.Max(xCursor.SelectionStart, xCursor.SelectionEnd);
460        double minY = Math.Min(yCursor.SelectionStart, yCursor.SelectionEnd);
461        double maxY = Math.Max(yCursor.SelectionStart, yCursor.SelectionEnd);
[3428]462
[3459]463        //check for click to select model
464        if (minX == maxX && minY == maxY) {
465          HitTestResult hitTest = chart.HitTest(e.X, e.Y);
466          if (hitTest.ChartElementType == ChartElementType.DataPoint) {
467            int pointIndex = hitTest.PointIndex;
468            IRun run = (IRun)this.chart.Series[0].Points[pointIndex].Tag;
469            run.Color = colorDialog.Color;
470          }
471        } else {
472          List<DataPoint> selectedPoints = new List<DataPoint>();
473          foreach (DataPoint p in this.chart.Series[0].Points) {
474            if (p.XValue >= minX && p.XValue < maxX &&
475              p.YValues[0] >= minY && p.YValues[0] < maxY) {
476              selectedPoints.Add(p);
477            }
478          }
479          foreach (DataPoint p in selectedPoints) {
480            IRun run = (IRun)p.Tag;
481            run.Color = colorDialog.Color;
482          }
[3428]483        }
[3638]484        this.chart.ChartAreas[0].CursorX.SelectionStart = this.chart.ChartAreas[0].CursorX.SelectionEnd;
485        this.chart.ChartAreas[0].CursorY.SelectionStart = this.chart.ChartAreas[0].CursorY.SelectionEnd;
[4888]486        Content.UpdateOfRunsInProgress = false;
[3428]487      }
488    }
489
[3411]490    private void chart_MouseMove(object sender, MouseEventArgs e) {
[3487]491      HitTestResult h = this.chart.HitTest(e.X, e.Y);
[3432]492      if (!Locked) {
493        if (this.draggedRun != null && h.ChartElementType != ChartElementType.DataPoint) {
494          DataObject data = new DataObject();
[5837]495          data.SetData(HeuristicLab.Common.Constants.DragDropDataFormat, draggedRun);
[3459]496          if (ReadOnly)
[3432]497            DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Link);
[3459]498          else {
[3432]499            DragDropEffects result = DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Link | DragDropEffects.Move);
500            if ((result & DragDropEffects.Move) == DragDropEffects.Move)
501              Content.Remove(draggedRun);
502          }
[3459]503          this.chart.ChartAreas[0].AxisX.ScaleView.Zoomable = !isSelecting;
504          this.chart.ChartAreas[0].AxisY.ScaleView.Zoomable = !isSelecting;
[3432]505          this.draggedRun = null;
[3411]506        }
507      }
[4212]508
[3524]509      string newTooltipText = string.Empty;
[3487]510      string oldTooltipText;
511      if (h.ChartElementType == ChartElementType.DataPoint) {
512        IRun run = (IRun)((DataPoint)h.Object).Tag;
[3524]513        newTooltipText = BuildTooltip(run);
[4212]514      } else if (h.ChartElementType == ChartElementType.AxisLabels) {
515        newTooltipText = ((CustomLabel)h.Object).ToolTip;
[3524]516      }
517
[3487]518      oldTooltipText = this.tooltip.GetToolTip(chart);
519      if (newTooltipText != oldTooltipText)
520        this.tooltip.SetToolTip(chart, newTooltipText);
[3411]521    }
[3524]522
523    private string BuildTooltip(IRun run) {
524      string tooltip;
525      tooltip = run.Name + System.Environment.NewLine;
526
527      double? xValue = this.GetValue(run, (string)xAxisComboBox.SelectedItem);
528      double? yValue = this.GetValue(run, (string)yAxisComboBox.SelectedItem);
529      double? sizeValue = this.GetValue(run, (string)sizeComboBox.SelectedItem);
530
531      string xString = xValue == null ? string.Empty : xValue.Value.ToString();
532      string yString = yValue == null ? string.Empty : yValue.Value.ToString();
533      string sizeString = sizeValue == null ? string.Empty : sizeValue.Value.ToString();
534
[4049]535      //code to handle TimeSpanValues correct
536      int axisDimensionCount = Enum.GetNames(typeof(AxisDimension)).Count();
537      int columnIndex = xAxisComboBox.SelectedIndex - axisDimensionCount;
538      if (xValue.HasValue && columnIndex > 0 && Content.GetValue(0, columnIndex) is TimeSpanValue) {
539        TimeSpan time = TimeSpan.FromSeconds(xValue.Value);
[4212]540        xString = string.Format("{0:00}:{1:00}:{2:00.00}", (int)time.TotalHours, time.Minutes, time.Seconds);
[4049]541      }
542      columnIndex = yAxisComboBox.SelectedIndex - axisDimensionCount;
543      if (yValue.HasValue && columnIndex > 0 && Content.GetValue(0, columnIndex) is TimeSpanValue) {
544        TimeSpan time = TimeSpan.FromSeconds(yValue.Value);
[4212]545        yString = string.Format("{0:00}:{1:00}:{2:00.00}", (int)time.TotalHours, time.Minutes, time.Seconds);
[4049]546      }
547
[3524]548      tooltip += xAxisComboBox.SelectedItem + " : " + xString + Environment.NewLine;
549      tooltip += yAxisComboBox.SelectedItem + " : " + yString + Environment.NewLine;
550      tooltip += sizeComboBox.SelectedItem + " : " + sizeString + Environment.NewLine;
551
552      return tooltip;
553    }
[3411]554    #endregion
555
556    #region GUI events and updating
557    private double GetXJitter(IRun run) {
558      if (!this.xJitter.ContainsKey(run))
559        this.xJitter[run] = random.NextDouble() * 2.0 - 1.0;
560      return this.xJitter[run];
561    }
562    private double GetYJitter(IRun run) {
563      if (!this.yJitter.ContainsKey(run))
564        this.yJitter[run] = random.NextDouble() * 2.0 - 1.0;
565      return this.yJitter[run];
566    }
567    private void jitterTrackBar_ValueChanged(object sender, EventArgs e) {
568      this.xJitterFactor = xTrackBar.Value / 100.0;
569      this.yJitterFactor = yTrackBar.Value / 100.0;
[5824]570      UpdateDataPointJitter();
[3411]571    }
[5330]572    private void sizeTrackBar_ValueChanged(object sender, EventArgs e) {
573      UpdateMarkerSizes();
574    }
[3411]575
[5330]576    private void AxisComboBox_SelectedValueChanged(object sender, EventArgs e) {
[4812]577      bool axisSelected = xAxisComboBox.SelectedIndex != -1 && yAxisComboBox.SelectedIndex != -1;
578      xTrackBar.Enabled = yTrackBar.Enabled = axisSelected;
579      colorXAxisButton.Enabled = colorYAxisButton.Enabled = axisSelected;
[4845]580
581      if (!xAxisComboBox.DroppedDown)
582        xAxisValue = (string)xAxisComboBox.SelectedItem;
583      if (!yAxisComboBox.DroppedDown)
584        yAxisValue = (string)yAxisComboBox.SelectedItem;
585      if (!sizeComboBox.DroppedDown)
586        sizeAxisValue = (string)sizeComboBox.SelectedItem;
587
[3411]588      UpdateDataPoints();
589      UpdateAxisLabels();
590    }
[3349]591    private void UpdateAxisLabels() {
592      Axis xAxis = this.chart.ChartAreas[0].AxisX;
593      Axis yAxis = this.chart.ChartAreas[0].AxisY;
[3536]594      int axisDimensionCount = Enum.GetNames(typeof(AxisDimension)).Count();
595      SetCustomAxisLabels(xAxis, xAxisComboBox.SelectedIndex - axisDimensionCount);
596      SetCustomAxisLabels(yAxis, yAxisComboBox.SelectedIndex - axisDimensionCount);
[4635]597      if (xAxisComboBox.SelectedItem != null)
598        xAxis.Title = xAxisComboBox.SelectedItem.ToString();
599      if (yAxisComboBox.SelectedItem != null)
600        yAxis.Title = yAxisComboBox.SelectedItem.ToString();
[3349]601    }
[4049]602
603    private void chart_AxisViewChanged(object sender, System.Windows.Forms.DataVisualization.Charting.ViewEventArgs e) {
604      this.UpdateAxisLabels();
605    }
606
[3411]607    private void SetCustomAxisLabels(Axis axis, int dimension) {
608      axis.CustomLabels.Clear();
[3349]609      if (categoricalMapping.ContainsKey(dimension)) {
610        foreach (var pair in categoricalMapping[dimension]) {
[3536]611          string labelText = pair.Key.ToString();
[4212]612          CustomLabel label = new CustomLabel();
613          label.ToolTip = labelText;
[3543]614          if (labelText.Length > 25)
615            labelText = labelText.Substring(0, 25) + " ... ";
[4212]616          label.Text = labelText;
[3349]617          label.GridTicks = GridTickTypes.TickMark;
[4212]618          label.FromPosition = pair.Value - 0.5;
619          label.ToPosition = pair.Value + 0.5;
620          axis.CustomLabels.Add(label);
[3349]621        }
[4049]622      } else if (dimension > 0 && Content.GetValue(0, dimension) is TimeSpanValue) {
623        this.chart.ChartAreas[0].RecalculateAxesScale();
624        for (double i = axis.Minimum; i <= axis.Maximum; i += axis.LabelStyle.Interval) {
625          TimeSpan time = TimeSpan.FromSeconds(i);
[4058]626          string x = string.Format("{0:00}:{1:00}:{2:00}", (int)time.Hours, time.Minutes, time.Seconds);
627          axis.CustomLabels.Add(i - axis.LabelStyle.Interval / 2, i + axis.LabelStyle.Interval / 2, x);
[4049]628        }
[3349]629      }
630    }
[3411]631
632    private void zoomButton_CheckedChanged(object sender, EventArgs e) {
633      this.isSelecting = selectButton.Checked;
634      this.colorButton.Enabled = this.isSelecting;
635      this.chart.ChartAreas[0].AxisX.ScaleView.Zoomable = !isSelecting;
636      this.chart.ChartAreas[0].AxisY.ScaleView.Zoomable = !isSelecting;
637    }
638    private void colorButton_Click(object sender, EventArgs e) {
639      if (colorDialog.ShowDialog(this) == DialogResult.OK) {
640        this.colorButton.Image = this.GenerateImage(16, 16, this.colorDialog.Color);
641      }
642    }
643    private Image GenerateImage(int width, int height, Color fillColor) {
644      Image colorImage = new Bitmap(width, height);
645      using (Graphics gfx = Graphics.FromImage(colorImage)) {
646        using (SolidBrush brush = new SolidBrush(fillColor)) {
647          gfx.FillRectangle(brush, 0, 0, width, height);
648        }
649      }
650      return colorImage;
651    }
[4653]652
653    private void openBoxPlotViewToolStripMenuItem_Click(object sender, EventArgs e) {
654      RunCollectionBoxPlotView boxplotView = new RunCollectionBoxPlotView();
655      boxplotView.Content = this.Content;
656      boxplotView.xAxisComboBox.SelectedItem = xAxisComboBox.SelectedItem;
657      boxplotView.yAxisComboBox.SelectedItem = yAxisComboBox.SelectedItem;
658      boxplotView.Show();
659    }
[3411]660    #endregion
[4799]661
[4888]662    #region Automatic coloring
[4799]663    private void colorXAxisButton_Click(object sender, EventArgs e) {
[4845]664      ColorRuns(xAxisValue);
[4799]665    }
666
667    private void colorYAxisButton_Click(object sender, EventArgs e) {
[4845]668      ColorRuns(yAxisValue);
669    }
670
671    private void ColorRuns(string axisValue) {
[4888]672      Content.UpdateOfRunsInProgress = true;
[4845]673      var runs = Content.Select(r => new { Run = r, Value = GetValue(r, axisValue) }).Where(r => r.Value.HasValue);
674      double minValue = runs.Min(r => r.Value.Value);
675      double maxValue = runs.Max(r => r.Value.Value);
676      double range = maxValue - minValue;
677
678      foreach (var r in runs) {
679        int colorIndex = 0;
680        if (!range.IsAlmost(0)) colorIndex = (int)((ColorGradient.Colors.Count - 1) * (r.Value.Value - minValue) / (maxValue - minValue));
681        r.Run.Color = ColorGradient.Colors[colorIndex];
[4799]682      }
[4888]683      Content.UpdateOfRunsInProgress = false;
[4799]684    }
685    #endregion
[5824]686
[3349]687  }
688}
Note: See TracBrowser for help on using the repository browser.