/// <summary>
/// Here when manipulation gives a delta.
/// </summary>
private void OnManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
Move(new Point(e.OriginX, e.OriginY),
new Vector(e.Delta.TranslationX, e.Delta.TranslationY),
e.Delta.Rotation,
e.Delta.ScaleX);
}
// </Snippet_GamePiece_OnManipulationStarted>
// <Snippet_GamePiece_OnManipulationDelta>
#region OnManipulationDelta
private void OnManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
//// Adjust the position and rotation of the game piece.
float deltaX = e.Delta.TranslationX;
float deltaY = e.Delta.TranslationY;
if (dragPoint.X != double.NaN || dragPoint.Y != double.NaN)
{
// Single-manipulator-drag-rotate mode. Adjust for drag / rotation
System.Windows.Point center = new System.Windows.Point(position.X, position.Y);
System.Windows.Vector toCenter = center - dragPoint;
double sin = Math.Sin(e.Delta.Rotation);
double cos = Math.Cos(e.Delta.Rotation);
System.Windows.Vector rotatedToCenter =
new System.Windows.Vector(
toCenter.X * cos - toCenter.Y * sin,
toCenter.X * sin + toCenter.Y * cos);
System.Windows.Vector shift = rotatedToCenter - toCenter;
deltaX += (float)shift.X;
deltaY += (float)shift.Y;
}
X += deltaX;
Y += deltaY;
rotation += e.Delta.Rotation;
}
/// <summary>
/// Here when manipulation gives a delta.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
ScreenMessage(String.Format("Delta: Rotation: {0}", e.Delta.Rotation));
Move(
e.Delta.TranslationX,
e.Delta.TranslationY,
e.Delta.Rotation,
e.Delta.ScaleX);
}
private void OnManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
if (pickedObject != null){
//Rotations================================================
float toRotate = MathHelper.ToDegrees(e.Delta.Rotation);
Quaternion q = pickedObject.Orientation;
double yaw = Math.Atan2(2.0 * (q.Y * q.Z + q.W * q.X), q.W * q.W - q.X * q.X - q.Y * q.Y + q.Z * q.Z);
double pitch = Math.Asin(-2.0 * (q.X * q.Z - q.W * q.Y));
double roll = Math.Atan2(2.0 * (q.X * q.Y + q.W * q.Z), q.W * q.W + q.X * q.X - q.Y * q.Y - q.Z * q.Z);
float currentRotation = MathHelper.ToDegrees((float)roll);
float finalRotation = currentRotation - toRotate;
if (finalRotation < 0)
{
finalRotation = 360 + finalRotation;
}
if (finalRotation > 360)
{
finalRotation = 360 - finalRotation;
}
float totalRotation = MathHelper.ToRadians(finalRotation);
Quaternion finalOrientation = Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1.0f), totalRotation);
this.orientation = finalOrientation;
//Zooms==================================================
Vector3 direction = viewManager.Position - pickedObject.Position;
Vector3 newPosition = pickedObject.Position;
direction.Normalize();
float scaleConstant = 1.5f;
float scaleFactor = e.Cumulative.ScaleX;
scaleFactor = scaleFactor < 1 ? -(1 / scaleFactor) : scaleFactor;
newPosition = Vector3.Add(Vector3.Multiply(direction, (scaleConstant * scaleFactor)), this.beginPos);
Segment s;
s.P1 = game.GraphicsDevice.Viewport.Unproject(new Vector3(touchPosition.X, touchPosition.Y, 0f),
viewManager.Projection, viewManager.View, Matrix.Identity);
s.P2 = game.GraphicsDevice.Viewport.Unproject(new Vector3(touchPosition.X, touchPosition.Y, 1f),
viewManager.Projection, viewManager.View, Matrix.Identity);
float scalar;
Vector3 point;
var c = physics.BroadPhase.Intersect(ref s, out scalar, out point);
pickedDistance = scalar;
//Put together=============================================
pickedObject.SetWorld(newPosition, finalOrientation);
}
}
/// <summary>
/// Handles the Delta event of the ScatterManipulationProcessor control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Input.Manipulations.Manipulation2DDeltaEventArgs"/> instance containing the event data.</param>
private void ScatterManipulationProcessor_Delta(object sender, Manipulation2DDeltaEventArgs e)
{
if (!_overridingScatterViewItem && e.Delta.ScaleX >= 1 &&
GetMaxScale() > 1 &&
(Math.Abs(ScatterViewItem.ActualWidth - ScatterViewItem.MaxWidth) <= .1 || Math.Abs(ScatterViewItem.ActualHeight - ScatterViewItem.MaxHeight) <= .1))
{
// If the SVI is scalled up to its maximum, steal its contacts and begin scaling the content.
_overridingScatterViewItem = true;
ScatterViewItem.TouchesCaptured.ToList().ForEach(c => c.Capture(this));
}
}
/// <summary>
/// Here when manipulation gives a delta.
/// </summary>
private void OnManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
if (!this.AreManipulationsEnabled)
{
return;
}
Move(new Point(e.OriginX, e.OriginY),
new Vector(e.Delta.TranslationX, e.Delta.TranslationY),
e.Delta.Rotation,
e.Delta.ScaleX);
}
// </Snippet_GamePiece_OnManipulationCompleted>
// <Snippet_GamePiece_OnInertiaDelta>
#region OnInertiaDelta
private void OnInertiaDelta(object sender, Manipulation2DDeltaEventArgs e)
{
// Adjust the position of the game piece.
X += e.Delta.TranslationX;
Y += e.Delta.TranslationY;
rotation += e.Delta.Rotation;
// Check to see if the piece has hit the edge of the view port.
bool reverseX = false;
bool reverseY = false;
if (X > viewport.Width)
{
reverseX = true;
X = viewport.Width;
}
else if (X < viewport.X)
{
reverseX = true;
X = viewport.X;
}
if (Y > viewport.Height)
{
reverseY = true;
Y = viewport.Height;
}
else if (Y < viewport.Y)
{
reverseY = true;
Y = viewport.Y;
}
if (reverseX || reverseY)
{
// Get the current velocities, reversing as needed.
// If reversing, apply sponge factor to slow the piece slightly.
float velocityX = e.Velocities.LinearVelocityX * ((reverseX) ? -spongeFactor : 1.0f);
float velocityY = e.Velocities.LinearVelocityY * ((reverseY) ? -spongeFactor : 1.0f);
// Must stop inertia processing before changing parameters.
if (inertiaProcessor.IsRunning)
{
inertiaProcessor.Complete(Timestamp);
}
// Assign the new velocities.
inertiaProcessor.TranslationBehavior.InitialVelocityX = velocityX;
inertiaProcessor.TranslationBehavior.InitialVelocityY = velocityY;
// Set flag so that inertia processing will continue.
processInertia = true;
}
}
private void OnManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
var deltaArguments = new ManipulationDeltaEventArgs(
_manipulationDevice,
LastTimestamp,
_currentContainer,
new Point(e.OriginX, e.OriginY),
ConvertDelta(e.Delta, null),
ConvertDelta(e.Cumulative, _lastManipulationBeforeInertia),
ConvertVelocities(e.Velocities),
IsInertiaActive);
PushEvent(deltaArguments);
}
private void OnManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
var deltaArguments = new ManipulationDeltaEventArgs(
_manipulationDevice,
LastTimestamp,
_currentContainer,
new Point(e.OriginX, e.OriginY),
ConvertDelta(e.Delta, null),
ConvertDelta(e.Cumulative, _lastManipulationBeforeInertia),
ConvertVelocities(e.Velocities),
IsInertiaActive);
PushEvent(deltaArguments);
}
private void unsolved_ManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
Canvas element = scene;
var matrix = GetUnsolvedTransform();
//if (e.Delta.ScaleX < 1)
// if (matrix.M11 <= 1.0 || matrix.M22 <= 1.0)
// return;
//matrix.ScaleAt(e.DeltaManipulation.Scale.X,
// e.DeltaManipulation.Scale.Y,
// e.ManipulationOrigin.X - this.ActualWidth / 2,
// e.ManipulationOrigin.Y - this.ActualHeight / 2);
var xScale = (e.Delta.ScaleX + 2) / 3;
var finalFact = matrix.M11 * xScale;
if (finalFact > MAX_ZOOM || finalFact < MIN_ZOOM)
{
return;
}
matrix.ScaleAt(xScale,
xScale,
e.OriginX - this.ActualWidth / 2,
e.OriginY - this.ActualHeight / 2);
//matrix.RotateAt(e.DeltaManipulation.Rotation,
// e.ManipulationOrigin.X,
// e.ManipulationOrigin.Y);
matrix.Translate(e.Delta.TranslationX,
e.Delta.TranslationY);
updateZoomFactor(matrix.M11);
SetWorkingAreaTransform(matrix, e.Delta.TranslationX < 0,
e.Delta.TranslationY < 0,
e.Delta.ScaleX > 1,
e.Delta.ScaleX < 1);
}
/// <summary>
/// Extract the Manipulation Data and write it into our Dictionary
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAffine2DDelta(object sender, Manipulation2DDeltaEventArgs e)
{
ReadOnlyTouchPointCollection currentContacts = contactTarget.GetState();
foreach (TouchPoint c in currentContacts)
{
if (c.X == e.OriginX && c.Y == e.OriginY)
{
// BugFix
// Apparently this event handling is not thread-safe
// Once the surface is reporting a bunch of touches (~30 in testing)
// It will try to add a moving touch multiple times to this dictionary.
//
// I've fixed this by only taking the last touch
// and just skip all the inbetween touches.
_contactManipulationData[c.Id] = e;
}
}
}
//private void Window_ManipulationStarting(object sender, Manipulation2DStartedEventArgs e)
//{
// //e.Handled = true;
// //e.ManipulationContainer = this;
//}
private void Window_ManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
//e.Handled = true;
unsolved_ManipulationDelta(sender, e);
}
//==========================================================//
/// <summary>
/// Event handler for the manipulation and inertia processor's delta events.
/// Occurs whenever the manipulation or inertia processors processes or extrapolate
/// manipulator data.
/// </summary>
/// <param name="sender">The manipulation or inertia processor that raised the event.</param>
/// <param name="e">The event args for the event.</param>
private void OnAffine2DDelta(object sender, Manipulation2DDeltaEventArgs e)
{
Debug.Assert(manipulating && sender is ManipulationProcessor2D ||
extrapolating && sender is InertiaProcessor2D);
Vector2 manipulationOrigin = new Vector2(e.OriginX, e.OriginY);
Vector2 manipulationDelta = new Vector2(e.Delta.TranslationX, e.Delta.TranslationY);
Vector2 previousOrigin = new Vector2(manipulationOrigin.X - manipulationDelta.X, manipulationOrigin.Y - manipulationDelta.Y);
float restrictedOrientation = RestrictOrientation(e.Delta.Rotation);
float restrictedScale = RestrictScale(e.Delta.ScaleX);
// Adjust the position of the item based on change in rotation
if (restrictedOrientation != 0.0f)
{
Vector2 manipulationOffset = transformedCenter - previousOrigin;
Vector2 rotatedOffset = GeometryHelper.RotatePointVector(manipulationOffset, restrictedOrientation);
Vector2 compensation = rotatedOffset - manipulationOffset;
transformedCenter += compensation;
}
// Adjust the position of the item based on change in scale
if (restrictedScale != 1.0f)
{
Vector2 manipulationOffset = manipulationOrigin - transformedCenter;
Vector2 scaledOffset = manipulationOffset * restrictedScale;
Vector2 compensation = manipulationOffset - scaledOffset;
transformedCenter += compensation;
}
// Rotate the item if it is allowed
if (canRotate || canRotateFlick)
{
orientation += restrictedOrientation;
}
// Scale the item if it is allowed
if (canScale || canScaleFlick)
{
scaleFactor *= restrictedScale;
}
// Translate the item if it is allowed
if (canTranslate || canTranslateFlick)
{
transformedCenter += new Vector2(e.Delta.TranslationX, e.Delta.TranslationY);
}
RestrictCenter();
if (canRotate || canRotateFlick)
{
manipulationProcessor.Pivot = new ManipulationPivot2D
{
X = transformedCenter.X,
Y = transformedCenter.Y,
Radius = Math.Max(Width, Height) / 2.0f
};
}
}
private void OnManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
if (!rotateOrZoom)
{
float newHeightAngle = MathHelper.ToRadians((MathHelper.ToDegrees(_viewManager.HeightAngle)
+ (JengaConstants.HEIGHT_REVERSED * e.Delta.TranslationY / JengaConstants.PAN_SPEED_DIVISOR)));
float newRotationAngle = MathHelper.ToRadians((MathHelper.ToDegrees(_viewManager.RotationAngle)
+ (JengaConstants.ROTATE_REVERSED * e.Delta.TranslationX / JengaConstants.PAN_SPEED_DIVISOR)));
_viewManager.updateCameraPosition(newRotationAngle, newHeightAngle, _viewManager.CameraDistance);
}else{
//Rotations================================================
float toRotate = MathHelper.ToDegrees(e.Delta.Rotation);
Quaternion q = selectedBrick.Item1.Orientation;
double yaw = Math.Atan2(2.0 * (q.Y * q.Z + q.W * q.X), q.W * q.W - q.X * q.X - q.Y * q.Y + q.Z * q.Z);
double pitch = Math.Asin(-2.0 * (q.X * q.Z - q.W * q.Y));
double roll = Math.Atan2(2.0 * (q.X * q.Y + q.W * q.Z), q.W * q.W + q.X * q.X - q.Y * q.Y - q.Z * q.Z);
float currentRotation = MathHelper.ToDegrees((float)roll);
float finalRotation = currentRotation - toRotate;
if (finalRotation < 0)
{
finalRotation = 360 + finalRotation;
}
if (finalRotation > 360)
{
finalRotation = 360 - finalRotation;
}
float totalRotation = MathHelper.ToRadians(finalRotation);
Quaternion finalOrientation = Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1.0f), totalRotation);
selectedBrick = new Tuple<SolidThing, Quaternion, float, Vector3>
(selectedBrick.Item1, finalOrientation, selectedBrick.Item3, selectedBrick.Item4);
//Zooms==================================================
Vector3 newPosition = selectedBrick.Item1.Position;
Vector3 direction = _viewManager.Position - selectedBrick.Item1.Position;
direction.Normalize();
float deltaAdd = 1 - e.Delta.ScaleX;
deltaAdd *= JengaConstants.FORWARD_BACK_BLOCK_SPEED;
newPosition = Vector3.Add(Vector3.Multiply(direction, deltaAdd), selectedBrick.Item1.Position);
if (Vector3.Subtract(_viewManager.Position, newPosition).Length() > JengaConstants.MIN_CAMERA_DISTANCE
|| Vector3.Subtract(_viewManager.Position, newPosition).Length() > Vector3.Subtract(_viewManager.Position, selectedBrick.Item1.Position).Length())
{
selectedBrick.Item1.IsActive = true;
selectedBrick.Item1.SetWorld(newPosition, selectedBrick.Item2);
}
}
}
/// <summary>
/// Translate and scale the content when it is manipulated.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Input.ManipulationDeltaEventArgs"/> instance containing the event data.</param>
private void ContentManipulationProcessor_Affine2DManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
if (GetMaxScale() == 1)
{
return;
}
// The inertia processor can move the content out of bounds.
if (sender == _inertiaProcessor)
{
_translate.X += e.Delta.TranslationX;
_translate.Y += e.Delta.TranslationY;
_scale.ScaleX *= e.Delta.ScaleX;
_scale.ScaleY *= e.Delta.ScaleY;
return;
}
_spring.Stop(this);
// Determine what scale to apply to the content.
bool returnControlToScatterViewItem = false;
double scaleDelta = 1;
double newScale = _scale.ScaleX * e.Delta.ScaleX;
if (_content.ActualWidth * newScale >= ActualWidth && newScale <= GetMaxScale())
{
// If the new scale is within the bounds, just use it directly.
scaleDelta = e.Delta.ScaleX;
}
else if (e.Delta.ScaleX > 1)
{
// Apply friction to an increasing scale.
scaleDelta = 1 + ((e.Delta.ScaleX - 1) * _friction);
}
else if (e.Delta.ScaleX < 1)
{
// Apply friction to a decreasing scale.
scaleDelta = 1 - ((1 - e.Delta.ScaleX) * _friction);
returnControlToScatterViewItem = _scale.ScaleX <= .95;
}
_scale.ScaleX *= scaleDelta;
_scale.ScaleY *= scaleDelta;
if (returnControlToScatterViewItem)
{
// If the content is scaled down to less than the default size, return control back to the ScatterViewItem.
if (ScatterViewItem != null)
{
TouchesCaptured.ToList().ForEach(c => c.Capture(ScatterViewItem));
_overridingScatterViewItem = false;
}
}
// Move the content.
_translate.X += e.Delta.TranslationX;
_translate.Y += e.Delta.TranslationY;
// Get the new bounds of the image.
Rect bounds = GetContentBounds();
if (bounds.TopLeft.X > 0 || bounds.BottomRight.X < ActualWidth)
{
// Apply friction if the content is out of bounds on the x-axis.
_translate.X -= e.Delta.TranslationX;
_translate.X += e.Delta.TranslationX * _friction;
}
if (bounds.TopLeft.Y > 0 || bounds.BottomRight.Y < ActualHeight)
{
// Apply friction if the content is out of bounds on the y-axis.
_translate.Y -= e.Delta.TranslationY;
_translate.Y += e.Delta.TranslationY * _friction;
}
}
//private void Window_ManipulationStarting(object sender, Manipulation2DStartedEventArgs e)
//{
// //e.Handled = true;
// //e.ManipulationContainer = this;
//}
private void Window_ManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
//e.Handled = true;
unsolved_ManipulationDelta(sender, e);
}
//==========================================================//
/// <summary>
/// Event handler for the manipulation and inertia processor's delta events.
/// Occurs whenever the manipulation or inertia processors processes or extrapolate
/// manipulator data
/// </summary>
/// <param name="sender">The manipulation or inertia processor that raised the event</param>
/// <param name="e">The event args for the event</param>
private void OnAffine2DDelta(object sender, Manipulation2DDeltaEventArgs e)
{
Debug.Assert(manipulating && sender is ManipulationProcessor2D ||
extrapolating && sender is InertiaProcessor2D);
Vector2 manipulationOrigin = new Vector2(e.OriginX, e.OriginY);
Vector2 manipulationDelta = new Vector2(e.Delta.TranslationX, e.Delta.TranslationY);
Vector2 previousOrigin = new Vector2(manipulationOrigin.X - e.Delta.TranslationX, manipulationOrigin.Y - e.Delta.TranslationY);
float restrictedOrientation = RestrictOrientation(e.Delta.Rotation);
// Scale is constrained (ScaleX==ScaleY), just use X
float restrictedScale = RestrictScale(e.Delta.ScaleX);
// Adjust the position of the item based on change in rotation
if (restrictedOrientation != 0.0f)
{
Vector2 manipulationOffset = center - previousOrigin;
Vector2 rotatedOffset = RotatePointVector(manipulationOffset, restrictedOrientation);
Vector2 compensation = rotatedOffset - manipulationOffset;
center += compensation;
}
// Adjust the position of the item based on change in scale
if (restrictedScale != 1.0f)
{
Vector2 manipulationOffset = manipulationOrigin - center;
Vector2 scaledOffset = manipulationOffset * restrictedScale;
Vector2 compensation = manipulationOffset - scaledOffset;
center += compensation;
}
// Rotate the item if it is allowed
if (canRotate || canRotateFlick)
{
orientation += restrictedOrientation;
}
// Scale the item if it is allowed
if (canScale || canScaleFlick)
{
scale *= restrictedScale;
}
// Translate the item if it is allowed
if (canTranslate || canTranslateFlick)
{
center += new Vector2(e.Delta.TranslationX, e.Delta.TranslationY);
}
RestrictCenter();
if (canRotate || canRotateFlick)
{
manipulationProcessor.Pivot = new ManipulationPivot2D
{
X = center.X,
Y = center.Y,
Radius = Math.Max(ActualSize.X, ActualSize.Y) / 2.0f,
};
}
SetConvertMatrix();
}
/// <summary>
/// Handles the Delta event of the ScatterManipulationProcessor control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Input.Manipulations.Manipulation2DDeltaEventArgs"/> instance containing the event data.</param>
private void ScatterManipulationProcessor_Delta(object sender, Manipulation2DDeltaEventArgs e)
{
if (!_overridingScatterViewItem && e.Delta.ScaleX >= 1 &&
GetMaxScale() > 1 &&
(Math.Abs(ScatterViewItem.ActualWidth - ScatterViewItem.MaxWidth) <= .1 || Math.Abs(ScatterViewItem.ActualHeight - ScatterViewItem.MaxHeight) <= .1))
{
// If the SVI is scalled up to its maximum, steal its contacts and begin scaling the content.
_overridingScatterViewItem = true;
ScatterViewItem.TouchesCaptured.ToList().ForEach(c => c.Capture(this));
}
}
/// <summary>
/// Translate and scale the content when it is manipulated.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Input.ManipulationDeltaEventArgs"/> instance containing the event data.</param>
private void ContentManipulationProcessor_Affine2DManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
if (GetMaxScale() == 1)
{
return;
}
// The inertia processor can move the content out of bounds.
if (sender == _inertiaProcessor)
{
_translate.X += e.Delta.TranslationX;
_translate.Y += e.Delta.TranslationY;
_scale.ScaleX *= e.Delta.ScaleX;
_scale.ScaleY *= e.Delta.ScaleY;
return;
}
_spring.Stop(this);
// Determine what scale to apply to the content.
bool returnControlToScatterViewItem = false;
double scaleDelta = 1;
double newScale = _scale.ScaleX * e.Delta.ScaleX;
if (_content.ActualWidth * newScale >= ActualWidth && newScale <= GetMaxScale())
{
// If the new scale is within the bounds, just use it directly.
scaleDelta = e.Delta.ScaleX;
}
else if (e.Delta.ScaleX > 1)
{
// Apply friction to an increasing scale.
scaleDelta = 1 + ((e.Delta.ScaleX - 1) * _friction);
}
else if (e.Delta.ScaleX < 1)
{
// Apply friction to a decreasing scale.
scaleDelta = 1 - ((1 - e.Delta.ScaleX) * _friction);
returnControlToScatterViewItem = _scale.ScaleX <= .95;
}
_scale.ScaleX *= scaleDelta;
_scale.ScaleY *= scaleDelta;
if (returnControlToScatterViewItem)
{
// If the content is scaled down to less than the default size, return control back to the ScatterViewItem.
if (ScatterViewItem != null)
{
TouchesCaptured.ToList().ForEach(c => c.Capture(ScatterViewItem));
_overridingScatterViewItem = false;
}
}
// Move the content.
_translate.X += e.Delta.TranslationX;
_translate.Y += e.Delta.TranslationY;
// Get the new bounds of the image.
Rect bounds = GetContentBounds();
if (bounds.TopLeft.X > 0 || bounds.BottomRight.X < ActualWidth)
{
// Apply friction if the content is out of bounds on the x-axis.
_translate.X -= e.Delta.TranslationX;
_translate.X += e.Delta.TranslationX * _friction;
}
if (bounds.TopLeft.Y > 0 || bounds.BottomRight.Y < ActualHeight)
{
// Apply friction if the content is out of bounds on the y-axis.
_translate.Y -= e.Delta.TranslationY;
_translate.Y += e.Delta.TranslationY * _friction;
}
}
/// <summary>
/// Update the position of the Value and the thumb each delta.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void OnAffine2DInertiaDelta(object sender, Manipulation2DDeltaEventArgs e)
{
float valueX = Value + ToValueSpace(e.Delta.TranslationX);
valueX = FlickUtilities.Clamp(valueX, 0, 1);
UpdatedValueInValueSpace(valueX);
}
/// <summary>
/// Extract the Manipulation Data and write it into our Dictionary
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAffine2DDelta(object sender, Manipulation2DDeltaEventArgs e)
{
ReadOnlyTouchPointCollection currentContacts = contactTarget.GetState();
foreach (TouchPoint c in currentContacts)
{
if (c.X == e.OriginX && c.Y == e.OriginY)
{
// BugFix
// Apparently this event handling is not thread-safe
// Once the surface is reporting a bunch of touches (~30 in testing)
// It will try to add a moving touch multiple times to this dictionary.
//
// I've fixed this by only taking the last touch
// and just skip all the inbetween touches.
_contactManipulationData[c.Id] = e;
}
}
}
/// <summary>
/// Update the changes to inertia processing.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAffine2DInertiaDelta(object sender, Manipulation2DDeltaEventArgs e)
{
if ((Orientation & Orientation.Horizontal) != 0)
{
// Inertia and Manipulations are both processed in ScreenSpace so we need to convert to value space and updated.
float valueX = horizontalScrollBarStateMachine.Value + ConvertFromHorizontalScreenToValueSpace(e.Delta.TranslationX);
// Clamp X
valueX = FlickUtilities.Clamp(valueX, 0, 1);
horizontalScrollBarStateMachine.Value = valueX;
}
if ((Orientation & Orientation.Vertical) != 0)
{
float valueY = verticalScrollBarStateMachine.Value + ConvertFromVerticalScreenToValueSpace(e.Delta.TranslationY);
// Clamp Y
valueY = FlickUtilities.Clamp(valueY, 0, 1);
// Update the scrollbars which will update the scroll viewer.
verticalScrollBarStateMachine.Value = valueY;
}
}
/// <summary>
/// Handles the Affine2DManipulationDelta event of the ManipulationProcessor. Attempts to distinguish scroll gestures
/// from those intended to manipulate the parent ScatterViewItem.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Input.Manipulation2DDeltaEventArgs"/> instance containing the event data.</param>
private void ManipulationProcessor_Delta(object sender, Manipulation2DDeltaEventArgs e)
{
if (_scatterViewItem == null)
{
// Hook up an event to the parent SVI. When it loses a contact, the ScrollViewer should capture them again.
_scatterViewItem = AssociatedObject.FindVisualParent <ScatterViewItem>();
_scatterViewItem.PreviewTouchUp += ScatterViewItem_PreviewContactUp;
}
if (_scatterViewItem == null)
{
// There's no SVI, so don't do anything.
return;
}
if (e.Delta.ExpansionX != 0 || e.Delta.ExpansionY != 0 || e.Delta.Rotation != 0)
{
// If any scale or rotation is detected, pass that to the SVI.
GiveControlToScatterViewItem();
return;
}
Vector translation = new Vector((double)e.Cumulative.TranslationX, (double)e.Cumulative.TranslationY);
if (Math.Abs(translation.Length) < 10)
{
// There's no translation, so don't do anything.
return;
}
if (AssociatedObject.ComputedHorizontalScrollBarVisibility == Visibility.Collapsed && AssociatedObject.ComputedVerticalScrollBarVisibility == Visibility.Collapsed)
{
// There are no scrollbars, so pass all translations to the SVI.
GiveControlToScatterViewItem();
return;
}
if (translation.Length >= SensitivityDistance)
{
// The scroll has gone for some distance, so assume the gesture is intended as a scroll and never do a drag.
_manipulationProcessor.CompleteManipulation(DateTime.UtcNow.Ticks);
return;
}
double translationAngle = Math.Abs(Math.Atan2(e.Cumulative.TranslationX, e.Cumulative.TranslationY) * (180 / Math.PI));
if (AssociatedObject.ComputedVerticalScrollBarVisibility == Visibility.Visible && AssociatedObject.ComputedHorizontalScrollBarVisibility == Visibility.Collapsed)
{
// The ScrollViewer is scrolling vertically.
if (translationAngle >= 90 - SensitivityAngle && translationAngle <= 90 + SensitivityAngle)
{
// The gesture scrolled horizontally, so pass that to the SVI.
GiveControlToScatterViewItem();
}
}
else if (AssociatedObject.ComputedVerticalScrollBarVisibility == Visibility.Collapsed && AssociatedObject.ComputedHorizontalScrollBarVisibility == Visibility.Visible)
{
// The ScrollViewer is scrolling horizontally.
if (e.Cumulative.TranslationX < 0)
{
// The gesture is scrolling to the left.
if (180 - translationAngle < SensitivityAngle)
{
// But it's close enough to vertical that it should go to the SVI.
GiveControlToScatterViewItem();
}
}
else if (e.Cumulative.TranslationX > 0)
{
// The gesture is scrolling to the right.
if (translationAngle <= SensitivityAngle)
{
// But it's close enough to vertical that it should go to the SVI.
GiveControlToScatterViewItem();
}
}
}
}
/// <summary>
/// Extract the Manipulation Data and write it into our Dictionary
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAffine2DDelta(object sender, Manipulation2DDeltaEventArgs e)
{
ReadOnlyTouchPointCollection currentContacts = contactTarget.GetState();
foreach (TouchPoint c in currentContacts)
{
if (c.X == e.OriginX && c.Y == e.OriginY)
{
_contactManipulationData.Add(c.Id, e);
}
}
}
// </Snippet_ManipulationItem_OnManipulationStarted>
// <Snippet_ManipulationItem_OnManipulationOrInertiaDelta>
#region OnManipulationOrInertiaDelta
private void OnManipulationOrInertiaDelta(object sender, Manipulation2DDeltaEventArgs e)
{
// The values obtained from e.Delta can be used to move, resize, or
// change the orientation of the element that is being manipulated.
}
//==========================================================//
/// <summary>
/// Event handler for the manipulation processor's delta event.
/// Occurs whenever the manipulation processor processes manipulator data.
/// </summary>
/// <param name="sender">The manipulation processor that raised the event.</param>
/// <param name="e">The event args for the event.</param>
private void OnAffine2DDelta(object sender, Manipulation2DDeltaEventArgs e)
{
// Check the raw manipulation values
float restrictedScale = RestrictScale(e.Delta.ScaleX);
Vector2 restrictedTranslation = RestrictTranslation(e.Delta.TranslationX, e.Delta.TranslationY, restrictedScale);
// Get the original and scaled offset from the manipulation origin to the center of the scatterview.
Vector2 originalManipulationOffset = new Vector2 ( e.OriginX, e.OriginY ) - transformedCenter;
Vector2 scaledManipulationOffset = originalManipulationOffset * restrictedScale;
// Remember the original center point
Vector2 originalCenter = transformedCenter;
// Scale the item
zoomFactor *= restrictedScale;
// Move the center of the scatter view towards the manipulation origin
transformedCenter += originalManipulationOffset - scaledManipulationOffset;
// Apply the translation
transformedCenter += restrictedTranslation;
// Children will have to be updated too
foreach (XnaScatterViewItem item in inactiveChildren)
{
Vector2 offsetToOriginalCenter = item.TransformedCenter - originalCenter;
offsetToOriginalCenter *= restrictedScale;
item.TransformedCenter = transformedCenter + offsetToOriginalCenter;
item.ZoomFactor *= restrictedScale;
}
}
private void unsolved_ManipulationDelta(object sender, Manipulation2DDeltaEventArgs e)
{
Canvas element = scene;
var matrix = GetUnsolvedTransform();
//if (e.Delta.ScaleX < 1)
// if (matrix.M11 <= 1.0 || matrix.M22 <= 1.0)
// return;
//matrix.ScaleAt(e.DeltaManipulation.Scale.X,
// e.DeltaManipulation.Scale.Y,
// e.ManipulationOrigin.X - this.ActualWidth / 2,
// e.ManipulationOrigin.Y - this.ActualHeight / 2);
var xScale = (e.Delta.ScaleX + 2)/3;
var finalFact = matrix.M11*xScale;
if (finalFact > MAX_ZOOM || finalFact < MIN_ZOOM)
return;
matrix.ScaleAt(xScale,
xScale,
e.OriginX - this.ActualWidth/2,
e.OriginY - this.ActualHeight/2);
//matrix.RotateAt(e.DeltaManipulation.Rotation,
// e.ManipulationOrigin.X,
// e.ManipulationOrigin.Y);
matrix.Translate(e.Delta.TranslationX,
e.Delta.TranslationY);
updateZoomFactor(matrix.M11);
SetWorkingAreaTransform(matrix, e.Delta.TranslationX < 0,
e.Delta.TranslationY < 0,
e.Delta.ScaleX > 1,
e.Delta.ScaleX < 1);
}
