private void MainPage_MouseMove(object sender, MouseEventArgs e)
{
  AddNewLine(e.GetPosition(this));
}
 
/// <summary>
/// Adds a new line at the given position
/// </summary>
private void AddNewLine(Point position)
{
  if (_lastPosition != null)
  {
    // find the angle in which the mouse is moving
    double angleOfMovement = RaidansToRadians(Math.Atan2(
        _lastPosition.Value.Y - position.Y, _lastPosition.Value.X - position.X)) + 90;
 
    // move our current angle slightly in this direction
    double diff = DifferenceBetweenAngles(_angle, angleOfMovement);
    _angle = _angle + DifferenceBetweenAngles(_angle, angleOfMovement) / 10;
 
    // create a line 
    double dx = Math.Sin(DegreesToRadians(_angle)) * diff;
    double dy = Math.Cos(DegreesToRadians(_angle)) * diff;
    Line line = new Line()
    {
      X1 = position.X + dx,
      Y1 = position.Y + dy,
      X2 = position.X - dx,
      Y2 = position.Y - dy,
      Opacity = 0.7,
      Stroke = new SolidColorBrush(Colors.Black),
      Tag = new Data() { Angle = _angle, Length = diff, Position = position }
    };
 
    // add to canvas
    LineContainer.Children.Add(line);
 
    // rotates all the lines that are currently displayed
    RotateLines();
  }
  _lastPosition = position;
}

/// <summary>
/// Creates a 'throttled' MouseMove event which ensures that the UI
/// rendering is not starved.
/// </summary>
public class ThrottledMouseMoveEvent
{
  private bool _awaitingRender = false;
 
  private UIElement _element;
 
  public ThrottledMouseMoveEvent(UIElement element)
  {
    _element = element;
    element.MouseMove += new MouseEventHandler(Element_MouseMove);
  }
 
  public event MouseEventHandler ThrottledMouseMove;
 
  private void Element_MouseMove(object sender, MouseEventArgs e)
  {
    if (!_awaitingRender)
    {
      // if we are not awaiting a render as a result of a previously handled event
      // raise a ThrottledMouseMove event, and add a Rendering handler so that
      // we can determine when this event has been acted upon.
      OnThrottledMouseMove(e);
      _awaitingRender = true;
      CompositionTarget.Rendering += CompositionTarget_Rendering;
    }      
  }
 
  private void CompositionTarget_Rendering(object sender, EventArgs e)
  {
    _awaitingRender = false;
    CompositionTarget.Rendering -= CompositionTarget_Rendering;
  }
 
  /// <summary>
  /// Raises the ThrottledMouseMove event
  /// </summary>
  protected void OnThrottledMouseMove(MouseEventArgs args)
  {
    if (ThrottledMouseMove!=null)
    {
      ThrottledMouseMove(_element, args);
    }
  }
}

// standard mouse move event handling
MouseHandler.MouseMove += new MouseEventHandler(MainPage_MouseMove);
 
// Replace with ...
 
// throttled mouse move event handling
var throttledEvent = new ThrottledMouseMoveEvent(MouseHandler);
throttledEvent.ThrottledMouseMove += new MouseEventHandler(ThrottledEvent_ThrottledMouseMove);

 /// <summary>
/// A class that adapts the MouseWheel event for a UIElement to ensure that 
/// multiple events are not handled and acted upon without the UI being re-rendered.
/// </summary>
public class ThrottledMouseWheelEvent
{
  #region fields
 
  /// <summary>
  /// Source element for the MouseWheel event
  /// </summary>
  private UIElement _source;
 
  /// <summary>
  /// The combined mouse-wheel delta
  /// </summary>
  private int _combinedDelta;
 
  /// <summary>
  /// A flag that indicates that a ThrottledMouseWheel event has been raised and we are waiting for
  /// the next Rendering event.
  /// </summary>
  private bool _awaitingRender = false;
 
  #endregion
 
  #region public API
 
  /// <summary>
  /// A 'throttled' MouseWheel event
  /// </summary>
  public event EventHandler<ThrottledMouseWheelEventArgs> ThrottledMouseWheel;
 
 
  public ThrottledMouseWheelEvent(UIElement source)
  {
    _source = source;
    _source.MouseWheel += new MouseWheelEventHandler(Source_MouseWheel);
  }
 
  #endregion
 
  #region private methods
 
  private void CompositionTarget_Rendering(object sender, EventArgs e)
  {
    Debug.WriteLine("CompositionTarget.Rendering Fired");
 
    if (_awaitingRender)
    {
      // if we have stored delta values, raise another ThrottledMouseWheel events
      if (_combinedDelta != 0)
      {
        OnThrottledMouseWheel(_combinedDelta);
      }
      _combinedDelta = 0;
      _awaitingRender = false;
    }
 
    CompositionTarget.Rendering -= CompositionTarget_Rendering;
  }
 
  /// <summary>
  /// Handles mouse wheel events from the source, either firing the ThrottledMouseWheel event,
  /// or queueing the event until a render has occured.
  /// </summary>
  private void Source_MouseWheel(object sender, MouseWheelEventArgs e)
  {
    Debug.WriteLine("Mousewheel Event e.Delta: " + e.Delta.ToString());
    if (!_awaitingRender)
    {
      // if we are not awaiting a render as a result of a previously handled event
      // raise a ThrottledMouseWheel event, and add a Rendering handler so that
      // we can determine when this event has been acted upon.
      OnThrottledMouseWheel(e.Delta);
      _combinedDelta = 0;
      _awaitingRender = true;
      CompositionTarget.Rendering += CompositionTarget_Rendering;
    }
    else
    {
      // if we are awaiting a render, store this delta value
      _combinedDelta += e.Delta;
    }
  }
 
  /// <summary>
  /// Raises the ThrottledMouseWheel event.
  /// </summary>
  protected void OnThrottledMouseWheel(int delta)
  {
    if (ThrottledMouseWheel != null)
    {
      ThrottledMouseWheel(_source, new ThrottledMouseWheelEventArgs()
      {
        Delta = delta
      });
    }
  }
 
  #endregion
}
 
/// <summary>
/// Provides data for the ThrottledMouseWheel event.
/// </summary>
public class ThrottledMouseWheelEventArgs : EventArgs
{
  public int Delta { get; internal set; }
}