void manipulationProcessor_Affine2DManipulationCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
inertiaProcessor.InitialOrigin = e.ManipulationOrigin;
inertiaProcessor.InitialVelocity = e.Velocity;
inertiaProcessor.InitialExpansionVelocity = e.ExpansionVelocity;
inertiaProcessor.InitialAngularVelocity = e.AngularVelocity;
inertiaProcessor.DesiredDeceleration = 0.002;
inertiaProcessor.DesiredAngularDeceleration = 0.0005f;
inertiaProcessor.DesiredExpansionDeceleration = 0.0002f;
inertiaProcessor.Begin();
}
/// <summary>
/// Unused
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAffine2DManipulationCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
}
/// <summary>
/// Start the flicking behavior.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAffine2DManipulationCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
if (inertiaProcessor != null)
{
inertiaProcessor.Affine2DInertiaDelta -= OnAffine2DInertiaDelta;
inertiaProcessor.Affine2DInertiaCompleted -= OnAffine2DInertiaCompleted;
inertiaProcessor = null;
}
// The Manipulations should all run in screen space so don't convert between spaces.
VectorF initialVelocity;
VectorF maxViewPortSize;
if (Orientation == Orientation.Horizontal)
{
initialVelocity = new VectorF(e.VelocityX, 0);
maxViewPortSize = new VectorF(numberOfPixelsInAxis * viewportSize, 0);
}
else
{
initialVelocity = new VectorF(0, e.VelocityY);
maxViewPortSize = new VectorF(0, numberOfPixelsInAxis * viewportSize);
}
// Check velocity.
if (initialVelocity.Length < FlickUtilities.MinimumFlickVelocity)
{
return;
}
if (initialVelocity.Length >= MaximumFlickVelocity)
{
// If velocity is too large, reduce it to a reasonable value.
initialVelocity.Normalize();
initialVelocity = MaximumFlickVelocity * initialVelocity;
}
VectorF flickDistance;
if (FlickUtilities.TryGetFlickDistance(initialVelocity, out flickDistance, maxViewPortSize))
{
processInertia = true;
inertiaProcessor = new Affine2DInertiaProcessor();
inertiaProcessor.Affine2DInertiaDelta += OnAffine2DInertiaDelta;
inertiaProcessor.Affine2DInertiaCompleted += OnAffine2DInertiaCompleted;
float displacement = 0;
if (flickDistance.X == 0)
{
displacement = flickDistance.Y;
}
else if (flickDistance.Y == 0)
{
displacement = flickDistance.X;
}
else
{
displacement = Math.Min(flickDistance.X, flickDistance.Y);
}
inertiaProcessor.DesiredDisplacement = float.IsInfinity(displacement) ? 0 : Math.Abs(displacement);
inertiaProcessor.InitialTimestamp = stopwatch.ElapsedTicks;
inertiaProcessor.InitialVelocityX = initialVelocity.X;
inertiaProcessor.InitialVelocityY = initialVelocity.Y;
inertiaProcessor.InitialOriginX = ToScreenSpace(Value);
inertiaProcessor.InitialOriginY = ToScreenSpace(Value);
}
}
/// <summary>
/// Set the flick to completed so that it stops moving.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void OnAffine2DInertiaCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
processInertia = false;
manipulationProcessor = null;
if (inertiaProcessor != null)
{
inertiaProcessor.Affine2DInertiaDelta -= new EventHandler<Affine2DOperationDeltaEventArgs>(OnAffine2DInertiaDelta);
inertiaProcessor.Affine2DInertiaCompleted -= new EventHandler<Affine2DOperationCompletedEventArgs>(OnAffine2DInertiaCompleted);
inertiaProcessor = null;
}
}
//==========================================================//
/// <summary>
/// Event handler for the manipulation processor's completed event.
/// Occurs whenever the manipulation processor processes manipulator
/// data where all remaining contacts have been removed.
/// Check final deltas and start the inertia processor if they are high enough
/// </summary>
/// <param name="sender">The manipulation processor that raised the event</param>
/// <param name="e">The event args for the event</param>
private void OnAffine2DManipulationCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
// manipulation completed
manipulating = false;
// Get the inital inertia values
//Vector2 initialVelocity = new Vector2(e.VelocityX, e.VelocityY);
float angularVelocity = e.AngularVelocity;
float expansionVelocity = e.ExpansionVelocity;
// Calculate the deceleration rates
// 4 inches/second squared (4 inches * 96 pixels per inch / (1000 per millisecond)^2)
const float deceleration = 4.0f * 96.0f / (1000.0f * 1000.0f);
const float expansionDeceleration = 4.0f * 96.0f / (1000.0f * 1000.0f);
// 90 degrees/second squared, specified in radians (180 * pi / (1000 per miliseconds)^2)
const float angularDeceleration = 90.0f / 180.0f * (float)Math.PI / (1000.0f * 1000.0f);
// Rotate around the center of the item
//inertiaProcessor.InitialOriginX = TransformedCenter.X;
//inertiaProcessor.InitialOriginY = TransformedCenter.Y;
inertiaProcessor.InitialOriginX = e.ManipulationOriginX;
inertiaProcessor.InitialOriginY = e.ManipulationOriginY;
// set initial velocity if translate flicks are allowed
//if (canTranslateFlick)
//{
inertiaProcessor.InitialVelocityX = e.VelocityX;
inertiaProcessor.InitialVelocityY = e.VelocityY;
inertiaProcessor.DesiredDeceleration = deceleration;
//}
/*else
{
inertiaProcessor.InitialVelocityX = 0.0f;
inertiaProcessor.InitialVelocityY = 0.0f;
inertiaProcessor.DesiredDeceleration = 0.0f;
}*/
// set expansion velocity if scale flicks are allowed
if (Math.Abs(expansionVelocity)> 0.00001 /*&& canScaleFlick*/)
{
inertiaProcessor.InitialExpansionVelocity = expansionVelocity;
//inertiaProcessor.InitialRadius = (AxisAlignedBoundingRectangle.Width / 2 + AxisAlignedBoundingRectangle.Height / 2) / 2;
inertiaProcessor.InitialRadius = 100;
inertiaProcessor.DesiredExpansionDeceleration = expansionDeceleration;
}
/*else
{
inertiaProcessor.InitialExpansionVelocity = 0.0f;
inertiaProcessor.InitialRadius = 1.0f;
inertiaProcessor.DesiredExpansionDeceleration = 0.0f;
}*/
// set angular velocity if rotation flicks are allowed
if (Math.Abs(angularVelocity)> 0.00001 /*&& canRotateFlick*/)
{
inertiaProcessor.InitialAngularVelocity = angularVelocity;
inertiaProcessor.DesiredAngularDeceleration = angularDeceleration;
}
/*else
{
inertiaProcessor.InitialAngularVelocity = 0.0f;
inertiaProcessor.DesiredAngularDeceleration = 0.0f;
}*/
// Set the boundaries in which manipulations can occur
/*inertiaProcessor.LeftBoundary = parent.Left - parent.BoundaryThreshold;
inertiaProcessor.RightBoundary = parent.Right + parent.BoundaryThreshold;
inertiaProcessor.TopBoundary = parent.Top - parent.BoundaryThreshold;
inertiaProcessor.BottomBoundary = parent.Bottom + parent.BoundaryThreshold;
*/
extrapolating = true;
}
//==========================================================//
/// <summary>
/// Event handler for the inertia processor's complete event.
/// Occurs whenever the item comes to rest after being flicked
/// </summary>
/// <param name="sender">The inertia processor that raised the event</param>
/// <param name="e">The event args for the event</param>
private void OnAffine2DInertiaCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
extrapolating = false;
}
/// <summary>
/// When the manipulation is completed, either spring the content back into bounds, or begin inertia.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Microsoft.Surface.Presentation.Manipulations.Affine2DOperationCompletedEventArgs"/> instance containing the event data.</param>
private void ContentManipulationProcessor_Affine2DManipulationCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
if (Spring())
{
return;
}
Rect bounds = GetContentBounds();
_inertiaProcessor.InitialOrigin = new Point();
_inertiaProcessor.InitialVelocity = e.Velocity;
_inertiaProcessor.Bounds = new Thickness(ActualWidth - bounds.BottomRight.X, ActualHeight - bounds.BottomRight.Y, -bounds.TopLeft.X, -bounds.TopLeft.Y);
_inertiaProcessor.Begin();
}
void inertiaProcessor_Affine2DInertiaCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
}
//==========================================================//
/// <summary>
/// Event handler for the inertia processor's complete event.
/// Occurs whenever the item comes to rest after being flicked
/// </summary>
/// <param name="sender">The inertia processor that raised the event</param>
/// <param name="e">The event args for the event</param>
private void OnAffine2DInertiaCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
extrapolating = false;
}
//==========================================================//
/// <summary>
/// Event handler for the manipulation processor's completed event.
/// Occurs whenever the manipulation processor processes manipulator
/// data where all remaining contacts have been removed.
/// Check final deltas and start the inertia processor if they are high enough
/// </summary>
/// <param name="sender">The manipulation processor that raised the event</param>
/// <param name="e">The event args for the event</param>
private void OnAffine2DManipulationCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
// manipulation completed
manipulating = false;
// Get the inital inertia values
//Vector2 initialVelocity = new Vector2(e.VelocityX, e.VelocityY);
float angularVelocity = e.AngularVelocity;
float expansionVelocity = e.ExpansionVelocity;
// Calculate the deceleration rates
// 4 inches/second squared (4 inches * 96 pixels per inch / (1000 per millisecond)^2)
const float deceleration = 4.0f * 96.0f / (1000.0f * 1000.0f);
const float expansionDeceleration = 4.0f * 96.0f / (1000.0f * 1000.0f);
// 90 degrees/second squared, specified in radians (180 * pi / (1000 per miliseconds)^2)
const float angularDeceleration = 90.0f / 180.0f * (float)Math.PI / (1000.0f * 1000.0f);
// Rotate around the center of the item
//inertiaProcessor.InitialOriginX = TransformedCenter.X;
//inertiaProcessor.InitialOriginY = TransformedCenter.Y;
inertiaProcessor.InitialOriginX = e.ManipulationOriginX;
inertiaProcessor.InitialOriginY = e.ManipulationOriginY;
// set initial velocity if translate flicks are allowed
//if (canTranslateFlick)
//{
inertiaProcessor.InitialVelocityX = e.VelocityX;
inertiaProcessor.InitialVelocityY = e.VelocityY;
inertiaProcessor.DesiredDeceleration = deceleration;
//}
/*else
* {
* inertiaProcessor.InitialVelocityX = 0.0f;
* inertiaProcessor.InitialVelocityY = 0.0f;
* inertiaProcessor.DesiredDeceleration = 0.0f;
* }*/
// set expansion velocity if scale flicks are allowed
if (Math.Abs(expansionVelocity) > 0.00001 /*&& canScaleFlick*/)
{
inertiaProcessor.InitialExpansionVelocity = expansionVelocity;
//inertiaProcessor.InitialRadius = (AxisAlignedBoundingRectangle.Width / 2 + AxisAlignedBoundingRectangle.Height / 2) / 2;
inertiaProcessor.InitialRadius = 100;
inertiaProcessor.DesiredExpansionDeceleration = expansionDeceleration;
}
/*else
* {
* inertiaProcessor.InitialExpansionVelocity = 0.0f;
* inertiaProcessor.InitialRadius = 1.0f;
* inertiaProcessor.DesiredExpansionDeceleration = 0.0f;
* }*/
// set angular velocity if rotation flicks are allowed
if (Math.Abs(angularVelocity) > 0.00001 /*&& canRotateFlick*/)
{
inertiaProcessor.InitialAngularVelocity = angularVelocity;
inertiaProcessor.DesiredAngularDeceleration = angularDeceleration;
}
/*else
* {
* inertiaProcessor.InitialAngularVelocity = 0.0f;
* inertiaProcessor.DesiredAngularDeceleration = 0.0f;
* }*/
// Set the boundaries in which manipulations can occur
/*inertiaProcessor.LeftBoundary = parent.Left - parent.BoundaryThreshold;
* inertiaProcessor.RightBoundary = parent.Right + parent.BoundaryThreshold;
* inertiaProcessor.TopBoundary = parent.Top - parent.BoundaryThreshold;
* inertiaProcessor.BottomBoundary = parent.Bottom + parent.BoundaryThreshold;
*/
extrapolating = true;
}
/// <summary>
/// Start the inertia processor in Surface screen space.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAffine2DManipulationCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
if (inertiaProcessor != null)
{
inertiaProcessor.Affine2DInertiaDelta -= OnAffine2DInertiaDelta;
inertiaProcessor.Affine2DInertiaCompleted -= OnAffine2DInertiaCompleted;
inertiaProcessor.Complete();
}
VectorF translation = new VectorF(e.TotalTranslationX, e.TotalTranslationY);
// Don't start inertia if the tranlation is less than roughly 1/8" regardless of velocity.
if (translation.Length < 96 / 8f)
{
return;
}
// Scroll in the opposite direction because a ScrollViewer moves with the contact.
VectorF initialVelocity = new VectorF(-e.VelocityX, -e.VelocityY);
// Check velocity.
if (initialVelocity.Length < FlickUtilities.MinimumFlickVelocity)
{
// If velocity is below this threshold ignore it.
return;
}
if (initialVelocity.Length >= FlickUtilities.MaximumFlickVelocity)
{
// If velocity is too large, reduce it to a reasonable value.
initialVelocity.Normalize();
initialVelocity = FlickUtilities.MaximumFlickVelocity * initialVelocity;
}
processInertia = true;
inertiaProcessor = new Affine2DInertiaProcessor();
inertiaProcessor.Affine2DInertiaDelta += OnAffine2DInertiaDelta;
inertiaProcessor.Affine2DInertiaCompleted += OnAffine2DInertiaCompleted;
inertiaProcessor.DesiredDisplacement = ConvertFromVerticalValueToScreenSpace(VerticalViewportSize);
inertiaProcessor.InitialVelocityX = initialVelocity.X * HorizontalViewportSize;
inertiaProcessor.InitialVelocityY = initialVelocity.Y * VerticalViewportSize;
inertiaProcessor.InitialTimestamp = stopwatch.ElapsedTicks;
inertiaProcessor.InitialOriginX = ConvertFromHorizontalValueToScreenSpace(horizontalScrollBarStateMachine.Value);
inertiaProcessor.InitialOriginY = ConvertFromVerticalValueToScreenSpace(verticalScrollBarStateMachine.Value);
}
/// <summary>
/// Inertia is complete so stop processing for it.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAffine2DInertiaCompleted(object sender, Affine2DOperationCompletedEventArgs e)
{
processInertia = false;
}
