using RealTimeGraphX.EventArguments;
using RealTimeGraphX.WPF.DataSeries;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
namespace RealTimeGraphX.WPF.Surfaces
{
/// <summary>
/// Represents a WPF implementation for <see cref="IGraphSurface{TImage}"/>.
/// This surface expects a graph image of type <see cref="BitmapSource"/>.
/// </summary>
/// <seealso cref="System.Windows.Controls.Control" />
/// <seealso cref="RealTimeGraphX.IGraphSurface{System.Windows.Media.Imaging.BitmapSource}" />
public class WpfGraphSurface : Control, IGraphSurface<WpfDataSeries, BitmapSource>
{
private Rectangle _selection_rectangle;
private Canvas _selection_canvas;
private bool _is_selection_mouse_down_zoom;
private bool _is_selection_mouse_down_pan;
private Point _selection_start_point;
private bool _is_scaled;
private Rect _pan_rect;
private Point _current_mouse_position;
private Point _last_mouse_position;
private Grid _grid;
#region Events
/// <summary>
/// Occurs when <see cref="IGraphPainter{TImage}"/> has changed.
/// </summary>
public event EventHandler<InputChangedEventArgs<IGraphPainter<WpfDataSeries, BitmapSource>>> InputChanged;
/// <summary>
/// Occurs when the surface size has changed.
/// </summary>
public event EventHandler<SurfaceSizeChangedEventArgs> SurfaceSizeChanged;
/// <summary>
/// Occurs when the connected input <see cref="IGraphPainter"/> has changed.
/// </summary>
event EventHandler<InputChangedEventArgs<IGraphPainter>> IGraphInputComponent<IGraphPainter>.InputChanged
{
add
{
InputChanged += new EventHandler<InputChangedEventArgs<IGraphPainter<WpfDataSeries, BitmapSource>>>((sender, e) => { value.Invoke(sender, new InputChangedEventArgs<IGraphPainter>(e.Input)); });
}
remove
{
InputChanged -= new EventHandler<InputChangedEventArgs<IGraphPainter<WpfDataSeries, BitmapSource>>>((sender, e) => { value.Invoke(sender, new InputChangedEventArgs<IGraphPainter>(e.Input)); });
}
}
#endregion
#region Properties
/// <summary>
/// Gets the current graph image.
/// </summary>
public BitmapSource Image
{
get { return (BitmapSource)GetValue(ImageProperty); }
private set { SetValue(ImageProperty, value); }
}
public static readonly DependencyProperty ImageProperty =
DependencyProperty.Register("Image", typeof(BitmapSource), typeof(WpfGraphSurface), new PropertyMetadata(null));
private double _surfaceWidth;
/// <summary>
/// Gets the width of the surface.
/// </summary>
public double SurfaceWidth
{
get
{
return _surfaceWidth;
}
private set
{
_surfaceWidth = value;
}
}
private double _surfaceHeight;
/// <summary>
/// Gets the height of the surface.
/// </summary>
public double SurfaceHeight
{
get
{
return _surfaceHeight;
}
private set
{
_surfaceHeight = value;
}
}
private IGraphPainter<WpfDataSeries,BitmapSource> _input;
/// <summary>
/// Gets the connected input <see cref="IGraphPainter{TImage}"/>.
/// </summary>
public IGraphPainter<WpfDataSeries,BitmapSource> Input
{
get
{
return _input;
}
private set
{
_input = value;
OnInputChanged(_input);
}
}
/// <summary>
/// Gets the connected input <see cref="IGraphPainter"/>.
/// </summary>
IGraphPainter IGraphInputComponent<IGraphPainter>.Input
{
get
{
return Input;
}
}
#endregion
#region Constructors
/// <summary>
/// Initializes the <see cref="WpfGraphSurface"/> class.
/// </summary>
static WpfGraphSurface()
{
DefaultStyleKeyProperty.OverrideMetadata(typeof(WpfGraphSurface), new FrameworkPropertyMetadata(typeof(WpfGraphSurface)));
}
/// <summary>
/// Initializes a new instance of the <see cref="WpfGraphSurface"/> class.
/// </summary>
public WpfGraphSurface()
{
SizeChanged += OnSizeChanged;
}
#endregion
#region Protected Methods
/// <summary>
/// Called when the mouse moves over the zoom/pan selection canvas.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="MouseEventArgs"/> instance containing the event data.</param>
protected virtual void OnSelectionCanvasMouseMove(object sender, MouseEventArgs e)
{
_current_mouse_position = e.GetPosition(_selection_canvas);
if (_is_selection_mouse_down_zoom && Keyboard.IsKeyDown(Key.LeftCtrl))
{
Canvas.SetLeft(_selection_rectangle, _selection_start_point.X);
Canvas.SetTop(_selection_rectangle, _selection_start_point.Y);
Point _selection_current_point = e.GetPosition(_selection_canvas);
if (_selection_current_point.X - _selection_start_point.X > 1)
{
_selection_rectangle.Width = _selection_current_point.X - _selection_start_point.X;
}
if (_selection_current_point.Y - _selection_start_point.Y > 1)
{
_selection_rectangle.Height = _selection_current_point.Y - _selection_start_point.Y;
}
if (_selection_current_point.X < _selection_start_point.X)
{
Canvas.SetLeft(_selection_rectangle, _selection_current_point.X);
_selection_rectangle.Width = _selection_start_point.X - _selection_current_point.X;
}
if (_selection_current_point.Y < _selection_start_point.Y)
{
Canvas.SetTop(_selection_rectangle, _selection_current_point.Y);
_selection_rectangle.Height = _selection_start_point.Y - _selection_current_point.Y;
}
}
else if (_is_selection_mouse_down_pan && _is_scaled)
{
Point _selection_current_point = e.GetPosition(_selection_canvas);
double delta_x = _current_mouse_position.X - _last_mouse_position.X;
double delta_y = _current_mouse_position.Y - _last_mouse_position.Y;
var renderer = Input;
double x = renderer.ZoomRect.Left - delta_x;
double y = renderer.ZoomRect.Top - delta_y;
if (x < 0)
{
x = 0;
}
if (y < 0)
{
y = 0;
}
if (x + renderer.ZoomRect.Width > SurfaceWidth)
{
x = x - (x + renderer.ZoomRect.Width - SurfaceWidth);
}
if (y + renderer.ZoomRect.Height > SurfaceHeight)
{
y = y - (y + renderer.ZoomRect.Height - SurfaceHeight);
}
Rect target_rect = new Rect(x, y, renderer.ZoomRect.Width, renderer.ZoomRect.Height);
renderer.SetZoomRect(target_rect.ToGraphRect());
}
_last_mouse_position = _current_mouse_position;
}
/// <summary>
/// Called when the mouse released from the zoom/pan selection canvas.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="MouseButtonEventArgs"/> instance containing the event data.</param>
protected virtual void OnSelectionCanvasMouseUp(object sender, MouseButtonEventArgs e)
{
_selection_canvas.ReleaseMouseCapture();
if (_is_selection_mouse_down_pan)
{
_is_selection_mouse_down_pan = false;
_pan_rect = Input.ZoomRect.ToWpfRect();
}
else if (_is_selection_mouse_down_zoom)
{
_is_selection_mouse_down_zoom = false;
Rect target_rect = new Rect(Canvas.GetLeft(_selection_rectangle), Canvas.GetTop(_selection_rectangle), _selection_rectangle.Width, _selection_rectangle.Height);
_pan_rect = target_rect;
Input.SetZoomRect(target_rect.ToGraphRect());
_selection_rectangle.Visibility = Visibility.Hidden;
_is_scaled = true;
}
}
/// <summary>
/// Called when the mouse pressed on the zoom/pan selection canvas.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="MouseButtonEventArgs"/> instance containing the event data.</param>
protected virtual void OnSelectionCanvasMouseDown(object sender, MouseButtonEventArgs e)
{
Mouse.Capture(_selection_canvas);
_selection_start_point = e.GetPosition(_selection_canvas);
_current_mouse_position = _selection_start_point;
_last_mouse_position = _current_mouse_position;
if (e.ClickCount == 2)
{
Input.ResetZoomRect();
_is_scaled = false;
}
else if (Keyboard.IsKeyDown(Key.LeftCtrl))
{
_selection_rectangle.Width = 0;
_selection_rectangle.Height = 0;
_is_selection_mouse_down_zoom = true;
_is_selection_mouse_down_pan = false;
_selection_rectangle.Visibility = Visibility.Visible;
}
else
{
_is_selection_mouse_down_pan = true;
}
}
/// <summary>
/// Called when the control size changes
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="SizeChangedEventArgs"/> instance containing the event data.</param>
protected virtual void OnSizeChanged(object sender, SizeChangedEventArgs e)
{
OnSurfaceSizeChanged(_grid.ActualWidth, _grid.ActualHeight);
}
/// <summary>
/// Called when surface size has changed.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
protected virtual void OnSurfaceSizeChanged(double width, double height)
{
SurfaceWidth = width;
SurfaceHeight = height;
SurfaceSizeChanged?.Invoke(this, new SurfaceSizeChangedEventArgs() { Width = width, Height = height });
if (Input != null)
{
Input.ResetZoomRect();
}
}
/// <summary>
/// Raises the <see cref="InputChanged"/> event.
/// </summary>
/// <param name="input">The input.</param>
protected virtual void OnInputChanged(IGraphPainter<WpfDataSeries, BitmapSource> input)
{
InputChanged?.Invoke(this, new InputChangedEventArgs<IGraphPainter<WpfDataSeries, BitmapSource>>(input));
}
/// <summary>
/// Called when the painter has deliverd a new image to display.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="PaintingCompletedEventArgs{BitmapSource}"/> instance containing the event data.</param>
protected virtual void OnPaintingCompleted(object sender, PaintingCompletedEventArgs<BitmapSource> e)
{
Image = e.Image;
}
#endregion
#region Apply Template
/// <summary>
/// When overridden in a derived class, is invoked whenever application code or internal processes call <see cref="M:System.Windows.FrameworkElement.ApplyTemplate" />.
/// </summary>
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
_selection_rectangle = GetTemplateChild("PART_SelectionRectangle") as Rectangle;
_selection_canvas = GetTemplateChild("PART_SelectionCanvas") as Canvas;
_grid = GetTemplateChild("PART_Grid") as Grid;
_selection_canvas.MouseDown += OnSelectionCanvasMouseDown;
_selection_canvas.MouseUp += OnSelectionCanvasMouseUp;
_selection_canvas.MouseMove += OnSelectionCanvasMouseMove;
}
#endregion
#region Public Methods
/// <summary>
/// Invokes a method on the surface thread.
/// </summary>
/// <param name="action">The action.</param>
public void InvokeOnSurface(Action action)
{
Dispatcher.BeginInvoke(action);
}
/// <summary>
/// Connects this surface to the specified <see cref="IGraphPainter{TImage}"/>.
/// </summary>
/// <param name="painter">The painter.</param>
/// <param name="fromInput">Specifies whether this call was made from an input <see cref="IGraphPainter{TImage}"/>.</param>
public void ConnectInput(IGraphPainter<WpfDataSeries,BitmapSource> painter, bool fromInput = false)
{
painter.ThrowIfNull("Cannot connect a null painter.");
DisconnectInput();
Input = painter;
Input.PaintingCompleted += OnPaintingCompleted;
if (!fromInput)
{
Input.ConnectOutput(this, true);
}
if (_grid != null)
{
OnSurfaceSizeChanged(_grid.ActualWidth, _grid.ActualHeight);
}
}
/// <summary>
/// Disconnects the current connected input <see cref="IGraphPainter"/>.
/// </summary>
/// <param name="fromInput">Specifies whether this call was made from an input <see cref="IGraphPainter"/>.</param>
public void DisconnectInput(bool fromInput = false)
{
if (Input != null)
{
if (!fromInput)
{
Input.DisconnectOutput(true);
}
Input.PaintingCompleted -= OnPaintingCompleted;
Input = null;
}
}
/// <summary>
/// Connects this surface to the specified <see cref="IGraphPainter"/>.
/// </summary>
/// <param name="painter">The painter.</param>
/// <param name="fromInput">Specifies whether this call was made from an input <see cref="IGraphPainter"/>.</param>
void IGraphInputComponent<IGraphPainter>.ConnectInput(IGraphPainter painter, bool fromInput)
{
ConnectInput(painter as IGraphPainter<WpfDataSeries, BitmapSource>, fromInput);
}
#endregion
}
}
