/// <summary>
/// Occurs when an input device begins a manipulation on the plot.
/// </summary>
/// <param name="e">
/// The <see cref="OxyPlot.OxyMouseEventArgs" /> instance containing the event data.
/// </param>
public override void Started(OxyMouseEventArgs e)
{
base.Started(e);
currentSeries = PlotView?.ActualModel?.Series
.FirstOrDefault(s => s.IsVisible) as DataPointSeries;
Delta(e);
}
private void Model_MouseMove(object sender, OxyMouseEventArgs e)
{
X = (int)(OxyPlot.Axes.Axis.InverseTransform(e.Position, Model.Axes[0], Model.Axes[1]).X);
if (isSelected)
{
if (RectangleUI == null)
{
startX = X;
RectangleUI = new RectangleBarItem(startX, Int16.MinValue, X, Int16.MaxValue);
RectangleUI.Color = OxyColor.FromArgb(100, 0, 0, 250);
Bar.Items.Add(RectangleUI);
}
else
{
RectangleUI.X1 = X;
}
Model.InvalidatePlot(true);
}
if (isPanBar && RectangleUI != null)
{
int offset = X - LastX;
RectangleUI.X0 += offset;
RectangleUI.X1 += offset;
//Process2((int)RectangleUI.X0, (int)RectangleUI.X1);
ProcessFFT();
LastX = X;
Model.InvalidatePlot(true);
}
}
/// <summary>
/// Occurs when an input device begins a manipulation on the plot.
/// </summary>
/// <param name="e">The <see cref="OxyInputEventArgs" /> instance containing the event data.</param>
public override void Started(OxyMouseEventArgs e)
{
base.Started(e);
var current = this.InverseTransform(e.Position.X, e.Position.Y);
double scale = this.Step;
if (this.FineControl)
{
scale *= 3;
}
scale = 1 + scale;
// make sure the zoom factor is not negative
if (scale < 0.1)
{
scale = 0.1;
}
if (this.XAxis != null)
{
this.XAxis.ZoomAt(scale, current.X);
}
if (this.YAxis != null)
{
this.YAxis.ZoomAt(scale, current.Y);
}
this.PlotView.InvalidatePlot(false);
}
public override void Started(OxyMouseEventArgs e)
{
base.Started(e);
this.PreviousPosition = e.Position;
this.IsPanEnabled = (this.XAxis != null && this.XAxis.IsPanEnabled) ||
(this.YAxis != null && this.YAxis.IsPanEnabled);
if (this.IsPanEnabled)
{
if (this.XAxis != null && this.YAxis != null)
{
this.View.SetCursorType(CursorType.Pan);
}
else if (this.XAxis == null && this.YAxis != null)
{
this.View.SetCursorType(CursorType.ZoomVertical);
}
else if (this.XAxis != null && this.YAxis == null)
{
this.View.SetCursorType(CursorType.ZoomHorizontal);
}
e.Handled = true;
}
}
private int EnergyScalePlot_MouseMove_Base(PlotModel energyscale_plot, OxyMouseEventArgs e)
{
Selected_Point.Size = 2;
int i_s = (int)energyscale_plot.Axes[0].InverseTransform(e.Position.X);
if (i_s > (State.Num_ScaleBins - 1))
{
i_s = (State.Num_ScaleBins - 1);
}
else if (i_s < 0)
{
i_s = 0;
}
Selected_Point = Selected_Series.Points[i_s];
Selected_Point.Size = 4;
Selected_Plot.InvalidatePlot(true);
label_X.Text = "X: " + i_s;
label_Y.Text = ", Y: " + Selected_Point.Y;
return(i_s);
}
public void PlotMouseMove(LineSeries lb, MapStatistics ms, OxyMouseEventArgs e)
{
if (lb.Points.Count != 0)
{
ms._endPoint1 = lb.InverseTransform(e.Position);
if (ms._startPoint1.X != 0 || ms._startPoint1.Y != 0)
{
ms._pm.Annotations.Clear();
var rectangle = new PolygonAnnotation();
rectangle.Layer = AnnotationLayer.BelowAxes;
rectangle.StrokeThickness = 0.5;
rectangle.Stroke = OxyColors.Red;
rectangle.Fill = OxyColors.Transparent;
rectangle.LineStyle = OxyPlot.LineStyle.Dot;
rectangle.Points.Add(new DataPoint(ms._startPoint1.X, ms._startPoint1.Y));
rectangle.Points.Add(new DataPoint(ms._endPoint1.X, ms._startPoint1.Y));
rectangle.Points.Add(new DataPoint(ms._endPoint1.X, ms._endPoint1.Y));
rectangle.Points.Add(new DataPoint(ms._startPoint1.X, ms._endPoint1.Y));
ms._pm.Annotations.Add(rectangle as Annotation);
ms._pm.InvalidatePlot(true);
}
}
}
private void Model_MouseUp(object sender, OxyMouseEventArgs e)
{
//if (e == OxyMouseButton.Left)
{
m_movingMouse = false;
}
}
private void DrawText_OnMouseUp(object sender, OxyMouseEventArgs args)
{
if (_tempAnnot == null)
return;
var annot = _tempAnnot as TextAnnotation;
if (annot != null)
{
annot.Background = OxyColors.Undefined;
if (string.IsNullOrEmpty(uiSetTextTextBox.Text))
{
using (var d = new InputTextDialog())
{
d.DisplayText = uiSetTextTextBox.Text;
if (d.ShowDialog() == DialogResult.OK)
annot.Text = d.DisplayText;
else
ChartModel.Annotations.Remove(annot);
}
}
else
annot.Text = uiSetTextTextBox.Text;
}
_tempAnnot = null;
ChartModel.InvalidatePlot(false);
args.Handled = true;
}
private void Plot_model_scroll_chart_MouseUp(object sender, OxyMouseEventArgs e)
{
scroll_mouse_down_value_X = 0;
scroll_chart_left_mouse_is_down = false;
e.Handled = true;
}
private void PlotMouseMove(object sender, OxyMouseEventArgs e)
{
//if (_lb.Points.Count != 0)
//{
// _ms._endPoint1 = _lb.InverseTransform(e.Position);
// if (_ms._startPoint1.X != 0 || _ms._startPoint1.Y != 0)
// {
// _ms._pm.Annotations.Clear();
// var rectangle = new PolygonAnnotation();
// rectangle.Layer = AnnotationLayer.BelowAxes;
// rectangle.StrokeThickness = 0.5;
// rectangle.Stroke = OxyColors.Red;
// rectangle.Fill = OxyColors.Transparent;
// rectangle.LineStyle = OxyPlot.LineStyle.Dot;
// rectangle.Points.Add(new DataPoint(_ms._startPoint1.X, _ms._startPoint1.Y));
// rectangle.Points.Add(new DataPoint(_ms._endPoint1.X, _ms._startPoint1.Y));
// rectangle.Points.Add(new DataPoint(_ms._endPoint1.X, _ms._endPoint1.Y));
// rectangle.Points.Add(new DataPoint(_ms._startPoint1.X, _ms._endPoint1.Y));
// _ms._pm.Annotations.Add(rectangle as Annotation);
// _ms._pm.InvalidatePlot(true);
// }
//}
_ms.PlotMouseMove(_lb, _ms, e);
}
private int EnergyScalePlot_MouseDown_Base(PlotModel energyscale_plot, OxyMouseEventArgs e)
{
int i_s = (int)energyscale_plot.Axes[0].InverseTransform(e.Position.X);
double y = energyscale_plot.Axes[1].InverseTransform(e.Position.Y);
int selected_index = 0;
double closest_dist = double.PositiveInfinity;
for (int i_p = 0; i_p < State.Num_Points; i_p++)
{
double dist = Math.Abs((energyscale_plot.Series[i_p] as OxyPlot.Series.ScatterSeries).Points[i_s].Y - y);
if (dist < closest_dist)
{
closest_dist = dist;
selected_index = i_p;
}
}
if (Selected_Point != null)
{
Selected_Point.Size = 2;
Selected_Plot.InvalidatePlot(true);
}
Selected_Plot = energyscale_plot;
Selected_Series = energyscale_plot.Series[selected_index] as OxyPlot.Series.ScatterSeries;
Selected_Point = Selected_Series.Points[i_s];
Selected_Index = selected_index;
Selected_Point.Size = 4;
label_X.Text = "X: " + i_s;
label_Y.Text = ", Y: " + Selected_Point.Y;
return(i_s);
}
private void ActualModel_MouseMove(object sender, OxyMouseEventArgs e)
{
if (mousedown)
{
PlotModel plot = PolynomialDiagramModel;
ElementCollection <OxyPlot.Axes.Axis> axisList = plot.Axes;
OxyPlot.Axes.Axis xAxis = null, yAxis = null;
foreach (OxyPlot.Axes.Axis ax in axisList)
{
if (ax.Position == OxyPlot.Axes.AxisPosition.Bottom)
{
xAxis = ax;
}
else if (ax.Position == OxyPlot.Axes.AxisPosition.Left)
{
yAxis = ax;
}
}
DataPoint p = OxyPlot.Axes.Axis.InverseTransform(e.Position, xAxis, yAxis);
if (p.X > PlotXRange)
{
PlotXRange = (int)p.X;
UpdatePolynomDiagram();
}
else if (p.X < -PlotXRange)
{
PlotXRange = (int)-p.X;
UpdatePolynomDiagram();
}
}
}
public override void Started(OxyMouseEventArgs e)
{
base.Started(e);
var isZoomEnabled = (this.XAxis != null && this.XAxis.IsZoomEnabled) ||
(this.YAxis != null && this.YAxis.IsZoomEnabled);
if (!isZoomEnabled)
{
return;
}
var current = this.InverseTransform(e.Position.X, e.Position.Y);
var scale = this.Step;
if (this.FineControl)
{
scale *= 3;
}
scale = 1 + scale;
// make sure the zoom factor is not negative
if (scale < 0.1)
{
scale = 0.1;
}
switch (AxisDescription)
{
case EAxisDescription.XY:
if (this.XAxis != null)
{
this.XAxis.ZoomAt(scale, current.X);
}
if (this.YAxis != null)
{
this.YAxis.ZoomAt(scale, current.Y);
}
break;
case EAxisDescription.X:
if (this.XAxis != null)
{
this.XAxis.ZoomAt(scale, current.X);
}
break;
case EAxisDescription.Y:
if (this.YAxis != null)
{
this.YAxis.ZoomAt(scale, current.Y);
}
break;
}
this.PlotView.InvalidatePlot(false);
e.Handled = true;
}
/// <summary>
/// Occurs when an input device begins a manipulation on the plot.
/// </summary>
/// <param name="e">The <see cref="OxyInputEventArgs" /> instance containing the event data.</param>
public override void Started(OxyMouseEventArgs e)
{
base.Started(e);
var current = this.InverseTransform(e.Position.X, e.Position.Y);
double scale = this.Step;
if (this.FineControl)
{
scale *= 3;
}
scale = 1 + scale;
// make sure the zoom factor is not negative
if (scale < 0.1)
{
scale = 0.1;
}
if (this.XAxis != null)
{
this.XAxis.ZoomAt(scale, current.X);
}
if (this.YAxis != null)
{
this.YAxis.ZoomAt(scale, current.Y);
}
this.PlotView.InvalidatePlot(false);
}
private void PlotMouseMove(object sender, OxyMouseEventArgs e)
{
if (_cs.Items.Count != 0)
{
_endPoint1 = _cs.InverseTransform(e.Position);
if (_startPoint1.X != 0 || _startPoint1.Y != 0)
{
_ms._pm.Annotations.Clear();
var rectangle = new PolygonAnnotation();
rectangle.Layer = AnnotationLayer.BelowAxes;
rectangle.StrokeThickness = 1;
rectangle.Stroke = OxyColors.Red;
rectangle.Fill = OxyColors.Transparent;
rectangle.LineStyle = OxyPlot.LineStyle.Dot;
rectangle.Points.Add(new DataPoint(_startPoint1.X, _startPoint1.Y));
rectangle.Points.Add(new DataPoint(_endPoint1.X, _startPoint1.Y));
rectangle.Points.Add(new DataPoint(_endPoint1.X, _endPoint1.Y));
rectangle.Points.Add(new DataPoint(_startPoint1.X, _endPoint1.Y));
_ms._pm.Annotations.Add(rectangle as Annotation);
_ms._pm.InvalidatePlot(true);
}
}
}
private void Plot_MouseUp(object sender, OxyMouseEventArgs e)
{
if (MouseMoveState == MoveState.CreatingRange)
{
// Don't create the range if it does not have a size set
if (Math.Abs(_activeRange.MinimumX - _activeRange.MaximumX) > 0.0001)
{
// Flip ends around if the user dragged backwards
if (_activeRange.MinimumX > _activeRange.MaximumX)
{
var temp = _activeRange.MaximumX;
_activeRange.MaximumX = _activeRange.MinimumX;
_activeRange.MinimumX = temp;
}
// Clamp to 0 if the user dragged behind the start
if (_activeRange.MinimumX < 0)
{
_activeRange.MinimumX = 0;
}
RangeCreated?.Invoke(_activeRange, _activeRange.MinimumX, _activeRange.MaximumX);
}
else
{
SetRanges.Remove(_activeRange);
_activeRange.MinimumX = _activeRange.MaximumX = 0;
RangeRemoved?.Invoke(_activeRange, _activeRange.MinimumX, _activeRange.MaximumX);
}
Model.InvalidatePlot(false);
}
MouseMoveState = MoveState.None;
}
private void Plot_MouseMove(object sender, OxyMouseEventArgs e)
{
if (MouseMoveState == MoveState.None)
{
return;
}
var x = PlotSeries.InverseTransform(e.Position).X;
if (MouseMoveState == MoveState.MovingRange)
{
var change = (x - _moveStartX) + _clickStartXOffset;
var size = Math.Abs(_clickedRange.MaximumX - _clickedRange.MinimumX);
_clickedRange.MinimumX = Math.Max(_moveStartX + change, 0);
_clickedRange.MaximumX = _clickedRange.MinimumX + size;
//model.Subtitle = string.Format("Integrating from {0:0.00} to {1:0.00}", range.MinimumX, range.MaximumX);
}
else
{
_activeRange.MinimumX = Math.Min(x, _clickStartX);
_activeRange.MaximumX = Math.Max(x, _clickStartX);
}
_activeRange.Text = $"{_activeRange.MinimumX / 1000:F0} - {_activeRange.MaximumX / 1000:F0}";
//model.Subtitle = string.Format("Integrating from {0:0.00} to {1:0.00}", range.MinimumX, range.MaximumX);
Model.InvalidatePlot(false);
e.Handled = true;
}
/// <summary>
/// Occurs when an input device begins a manipulation on the plot.
/// </summary>
/// <param name="e">The <see cref="OxyPlot.OxyMouseEventArgs" /> instance containing the event data.</param>
public override void Started(OxyMouseEventArgs e)
{
base.Started(e);
this.currentSeries = this.PlotView.ActualModel != null?this.PlotView.ActualModel.GetSeriesFromPoint(e.Position) : null;
this.Delta(e);
}
private void Model_MouseUp(object sender, OxyMouseEventArgs e)
{
isPanBar = false;
if (RectangleUI != null && isSelected)
{
if (Math.Abs(RectangleUI.X1 - RectangleUI.X0) < 10)
{
ClearBar();
SelectedData.Clear();
}
else
{
double min = RectangleUI.X0 < RectangleUI.X1 ? RectangleUI.X0 : RectangleUI.X1;
double max = RectangleUI.X0 > RectangleUI.X1 ? RectangleUI.X0 : RectangleUI.X1;
RectangleUI = new RectangleBarItem(min, Int16.MinValue, max, Int16.MaxValue);
RectangleUI.Color = OxyColor.FromArgb(100, 250, 0, 0);
Bar.Items.Add(RectangleUI);
Bar.Items.RemoveAt(0);
Line.Points.Where(point => point.X > min && point.X < max).ToList().ForEach(p =>
{
SelectedData.Add(new Complex(p.Y, 0));
});
LastX = (int)min;
Debug.WriteLine(SelectedData.Count());
}
}
isSelected = false;
}
private void myModel_MouseMove(object sender, OxyMouseEventArgs ex)
{
if (PlotMouseDown && StartROISet)
{
double dataTmp = xValueAxis.InverseTransform(ex.Position.X);
switch (ROIState)
{
case 0:
case 2:
ROI1.Points.Clear();
ROI1.Points.Add(new DataPoint(dataTmp, -100000));
ROI1.Points.Add(new DataPoint(dataTmp, 100000));
ROIX[0] = dataTmp;
myModel.InvalidatePlot(true);
break;
case 1:
case 3:
ROI2.Points.Clear();
ROI2.Points.Add(new DataPoint(dataTmp, -100000));
ROI2.Points.Add(new DataPoint(dataTmp, 100000));
ROIX[1] = dataTmp;
myModel.InvalidatePlot(true);
break;
}
}
}
private void Plot_MouseMove(object sender, OxyMouseEventArgs e)
{
if (isMouseRightButtonDown)
{
DrawFunctions();
}
}
private static void ProcLostTimePlot_MouseDown(object sender, OxyMouseEventArgs e,
ViewController viewController, int intervalNum)
{
DateTime now = DateTime.Now;
if (now.Subtract(procSelectionLastClick).TotalMilliseconds < 500.0)
{
var s = sender as ColumnSeries;
var nearest = s.GetNearestPoint(e.Position, false);
var i = (int)nearest.DataPoint.X;
var model = s.PlotModel;
foreach (var ser in model.Series)
{
var color = (ser as ColumnSeries).FillColor;
model.InvalidatePlot(true);
for (int j = 0; j < (ser as ColumnSeries).Items.Count; ++j)
{
(ser as ColumnSeries).Items[j].Color =
color.ChangeSaturation((j == i) ? 1 : 0.5);
}
}
viewController.SelectProcessor(i, intervalNum);
}
procSelectionLastClick = now;
}
private void PlotModel_MouseMove(object sender, OxyMouseEventArgs e)
{
CursorPosition = viewModel.GetComplexCursorPositionOnPlot(e.Position);
if (w.f is Hydrodynamics_Sources.Conformal_Maps.Diffusor && CursorPosition.Im < 0)
{
V = w.V_physical_plane(CursorPosition.Conjugate);
V = V.Conjugate;
}
else
{
V = w.V_physical_plane(CursorPosition);
}
if (w.f is Hydrodynamics_Sources.Conformal_Maps.EjectedRays && CursorPosition.Re < 0 && (Math.Abs(CursorPosition.Im) < CursorPosition.Re * Math.Tan((w.f as Hydrodynamics_Sources.Conformal_Maps.EjectedRays).Angle)))
{
V = -V;
}
if (w.f is Hydrodynamics_Sources.Conformal_Maps.EjectedRays && CursorPosition.Re < 0 && (w.f as Hydrodynamics_Sources.Conformal_Maps.EjectedRays).Angle == Mathematical_Sources.MathematicalConstants.PiDividedOnTwo)
{
V = -V;
}
if (Complex.IsNaN(V) || IsCursorInBorder())
{
ClearTextBoxes();
return;
}
else
{
xTextBox.Text = CursorPosition.Re.ToString(Settings.Format);
yTextBox.Text = CursorPosition.Im.ToString(Settings.Format);
VxTextBox.Text = V.Re.ToString(Settings.Format);
VyTextBox.Text = V.Im.ToString(Settings.Format);
}
}
private void DrawLine_OnMouseMove(object sender, OxyMouseEventArgs args)
{
if (_tempAnnot == null)
return;
Axis xAxis = ChartModel.Axes.First(a => a.IsHorizontal());
Axis yAxis = ChartModel.Axes.First(a => a.IsVertical());
var type = (LimitType) uiSetTypeComboBox.SelectedItem;
var annot = _tempAnnot as LineAnnotation;
if (annot != null)
{
if (type == LimitType.None)
{
double x1 = annot.X;
double x2 = xAxis.InverseTransform(args.Position.X);
double y1 = annot.Y;
double y2 = yAxis.InverseTransform(args.Position.Y);
double slope = (y2 - y1) / (x2 - x1);
annot.Intercept = y2 - slope * x2;
annot.Slope = slope;
}
else if (type == LimitType.Vertical)
annot.X = xAxis.InverseTransform(args.Position.X);
else if (type == LimitType.Horizontal)
annot.Y = yAxis.InverseTransform(args.Position.Y);
}
ChartModel.InvalidatePlot(false);
args.Handled = true;
}
private void ReallyCompleted(OxyMouseEventArgs e)
{
base.Completed(e);
// Must unhook or this object will live as long as the model (instead of as long as the manipulation)
_plotModel.TrackerChanged -= HandleTrackerChanged;
}
public void pm_MouseUp(object sender, OxyMouseEventArgs e)
{
if (this.coupling_isEnabled && this.coupling_isMeasure)
{
coupling_end = new DataPoint(this.getActivePlotView().Model.Axes[0].InverseTransform(e.Position.X), this.getActivePlotView().Model.Axes[1].InverseTransform(e.Position.Y));
coupling_isEnabled = false;
coupling_isMeasure = false;
this.mdiTabMenu.BorderBrush = new SolidColorBrush(Color.FromArgb(255, 63, 81, 181));
EPRPlotView pw = this.getActivePlotView();
this.CouplingButton.Foreground = Brushes.Black;
pw.Model.Annotations.Clear();
pw.spc.A.Add(new Tuple <DataPoint, DataPoint>(coupling_start, coupling_end));
this.RefreshData();
}
if (this.g_isPicking)
{
this.getActiveSpectrum().g.Add(this.getActiveSpectrum().calcG(this.getActivePlotView().Model.Axes[0].InverseTransform(e.Position.X)));
this.g_isPicking = false;
this.mdiTabMenu.BorderBrush = new SolidColorBrush(Color.FromArgb(255, 63, 81, 181));
this.gButton.Foreground = Brushes.Black;
//refresh couplings && g
this.RefreshData();
}
}
private void PlotModel_MouseMove(object sender, OxyMouseEventArgs e)
{
#if !HELP_FOR_GROUP_LEADER
CursorPosition = viewModel.GetComplexCursorPositionOnPlot(e.Position);
if (w.f is Hydrodynamics_Sources.Conformal_Maps.IdentityTransform)
{
V = w.V_physical_plane(CursorPosition);
if (Complex.IsNaN(V) || IsCursorInBorder())
{
ClearTextBoxes();
return;
}
else
{
xTextBox.Text = CursorPosition.Re.ToString(Settings.Format);
yTextBox.Text = CursorPosition.Im.ToString(Settings.Format);
VxTextBox.Text = V.Re.ToString(Settings.Format);
VyTextBox.Text = V.Im.ToString(Settings.Format);
}
}
else
{
xTextBox.Text = CursorPosition.Re.ToString(Settings.Format);
yTextBox.Text = CursorPosition.Im.ToString(Settings.Format);
VxTextBox.Text = string.Empty;
VyTextBox.Text = string.Empty;
}
#endif
}
private void PlotMouseDown(object sender, OxyMouseEventArgs e)
{
// if (e.ChangedButton == OxyMouseButton.Left) {
MovingSeries = PlotModel.GetSeriesFromPoint(e.Position) as MapLineSeries;
MoveLastPosition = BottomAxis.InverseTransform(e.Position.X, e.Position.Y, LeftAxis);
//e.Handled = true;
// }
}
private void PlotMouseUp(object sender, OxyMouseEventArgs e)
{
if (MovingSeries != null)
{
MovingSeries = null;
// e.Handled = true;
}
}
private void OnModelOnMouseUp(object s, OxyMouseEventArgs e)
{
if (!double.IsNaN(_startx))
{
_startx = double.NaN;
RangeChangedFromMouseSelection?.Invoke(this, EventArgs.Empty);
}
}
/// <summary>
/// Occurs when a manipulation is complete.
/// </summary>
/// <param name="e">
/// The <see cref="OxyPlot.OxyMouseEventArgs" /> instance containing the event data.
/// </param>
public override void Completed(OxyMouseEventArgs e)
{
base.Completed(e);
e.Handled = true;
currentSeries = null;
PlotView.HideTracker();
}
/// <summary>
/// Occurs when a manipulation is complete.
/// </summary>
/// <param name="e">The <see cref="OxyPlot.OxyMouseEventArgs" /> instance containing the event data.</param>
public override void Completed(OxyMouseEventArgs e)
{
base.Completed(e);
this.currentSeries = null;
this.PlotView.HideTracker();
if (this.PlotView.ActualModel != null)
{
this.PlotView.ActualModel.OnTrackerChanged(null);
}
}
/// <summary>
/// Occurs when the input device changes position during a manipulation.
/// </summary>
/// <param name="e">The <see cref="OxyPlot.OxyMouseEventArgs" /> instance containing the event data.</param>
public override void Delta(OxyMouseEventArgs e)
{
base.Delta(e);
if (this.XAxis != null)
{
this.XAxis.Pan(this.PreviousPosition, e.Position);
}
if (this.YAxis != null)
{
this.YAxis.Pan(this.PreviousPosition, e.Position);
}
this.PlotView.InvalidatePlot(false);
this.PreviousPosition = e.Position;
}
/// <summary>
/// Occurs when the input device changes position during a manipulation.
/// </summary>
/// <param name="e">The <see cref="OxyPlot.OxyMouseEventArgs" /> instance containing the event data.</param>
public override void Delta(OxyMouseEventArgs e)
{
base.Delta(e);
if (this.currentSeries == null || !this.LockToInitialSeries)
{
// get the nearest
this.currentSeries = this.PlotView.ActualModel != null ? this.PlotView.ActualModel.GetSeriesFromPoint(e.Position, 20) : null;
}
if (this.currentSeries == null)
{
if (!this.LockToInitialSeries)
{
this.PlotView.HideTracker();
}
return;
}
var actualModel = this.PlotView.ActualModel;
if (actualModel == null)
{
return;
}
if (!actualModel.PlotArea.Contains(e.Position.X, e.Position.Y))
{
return;
}
var result = GetNearestHit(this.currentSeries, e.Position, this.Snap, this.PointsOnly);
if (result != null)
{
result.PlotModel = this.PlotView.ActualModel;
this.PlotView.ShowTracker(result);
this.PlotView.ActualModel.OnTrackerChanged(result);
}
}
/// <summary>
/// Occurs when an input device begins a manipulation on the plot.
/// </summary>
/// <param name="e">The <see cref="OxyPlot.OxyMouseEventArgs" /> instance containing the event data.</param>
public override void Started(OxyMouseEventArgs e)
{
base.Started(e);
this.PreviousPosition = e.Position;
}
/// <summary>
/// Zooms the view by the specified factor at the position specified in the <see cref="OxyMouseEventArgs" />.
/// </summary>
/// <param name="view">The view.</param>
/// <param name="args">The <see cref="OxyMouseWheelEventArgs" /> instance containing the event data.</param>
/// <param name="delta">The zoom factor.</param>
private static void HandleZoomAt(IPlotView view, OxyMouseEventArgs args, double delta)
{
var m = new ZoomStepManipulator(view) { Step = delta, FineControl = args.IsControlDown };
m.Started(args);
}
/// <summary>
/// Occurs when an input device begins a manipulation on the plot.
/// </summary>
/// <param name="e">The <see cref="OxyPlot.OxyMouseEventArgs" /> instance containing the event data.</param>
public override void Started(OxyMouseEventArgs e)
{
base.Started(e);
this.currentSeries = this.PlotView.ActualModel != null ? this.PlotView.ActualModel.GetSeriesFromPoint(e.Position) : null;
this.Delta(e);
}