private void ProcessManipulationInertiaDelta(Affine2DOperationDeltaEventArgs e)
{
if (MapManipulationMode == MapManipulationMode.PanZoomPivot)
{
if (IsPanEnabled)
{
DoMapMove(e.Delta.X * PanSensitivity, e.Delta.Y * PanSensitivity);
}
}
else
{
if (IsSpinEnabled)
{
double deltaAngle = InfoStrat.VE.Utilities.MathHelper.MapValue(e.Delta.X, -20, 20, -1, 1);
DoMapYaw(deltaAngle);
}
if (IsTiltEnabled)
{
double desiredPitch = ClampPitch(this.Pitch + e.Delta.Y * TiltSensitivity, this.Altitude);
DoMapTilt(desiredPitch);
}
}
if (IsZoomEnabled)
{
DoMapZoom(e.ExpansionDelta * ZoomSensitivity, e.ManipulationOrigin);
}
if (IsPivotEnabled)
{
DoMapPivot(e.RotationDelta, e.ManipulationOrigin);
}
}
//==========================================================//
/// <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, Affine2DOperationDeltaEventArgs e)
{
//Debug.Assert(manipulating && sender is Affine2DManipulationProcessor ||
// extrapolating && sender is Affine2DInertiaProcessor);
openCOVER.manipulation(e);
//Vector2 manipulationOrigin = new Vector2(e.ManipulationOriginX, e.ManipulationOriginY);
//Vector2 manipulationDelta = new Vector2(e.DeltaX, e.DeltaY);
//Vector2 previousOrigin = new Vector2(manipulationOrigin.X - manipulationDelta.X, manipulationOrigin.Y - manipulationDelta.Y);
//float restrictedOrientation = RestrictOrientation(e.RotationDelta);
//float restrictedScale = RestrictScale(e.ScaleDelta);
// 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.DeltaX, e.DeltaY);
* }
*
* RestrictCenter();
*
* if (canRotate || canRotateFlick)
* {
* manipulationProcessor.PivotX = transformedCenter.X;
* manipulationProcessor.PivotY = transformedCenter.Y;
* manipulationProcessor.PivotRadius = Math.Max(Width, Height) / 2.0f;
* }*/
}
private void OnManipulationDelta(object sender, Affine2DOperationDeltaEventArgs e)
{
logoRotateTransform.Angle += e.RotationDelta;
DeltaManipulationFinished(this, e);
}
/// <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, Affine2DOperationDeltaEventArgs e)
{
ReadOnlyContactCollection currentContacts = contactTarget.GetState();
foreach (Contact c in currentContacts)
{
if (c.X == e.ManipulationOriginX && c.Y == e.ManipulationOriginY)
{
_contactManipulationData.Add(c.Id, e);
}
}
}
/// <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, Affine2DOperationDeltaEventArgs e)
{
float valueX = Value + ToValueSpace(e.DeltaX);
valueX = FlickUtilities.Clamp(valueX, 0, 1);
UpdatedValueInValueSpace(valueX);
}
/// <summary>
/// Rotation of MenuCard using ManipulationProcessor
/// </summary>
/// <returns></returns>
public void OnManipulationDelta(object sender, Affine2DOperationDeltaEventArgs e)
{
cardRotateTransform.Angle += e.RotationDelta;
}
private void manipulationDelta(object sender, Affine2DOperationDeltaEventArgs 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, Affine2DOperationDeltaEventArgs e)
{
//Debug.Assert(manipulating && sender is Affine2DManipulationProcessor ||
// extrapolating && sender is Affine2DInertiaProcessor);
openCOVER.manipulation(e);
//Vector2 manipulationOrigin = new Vector2(e.ManipulationOriginX, e.ManipulationOriginY);
//Vector2 manipulationDelta = new Vector2(e.DeltaX, e.DeltaY);
//Vector2 previousOrigin = new Vector2(manipulationOrigin.X - manipulationDelta.X, manipulationOrigin.Y - manipulationDelta.Y);
//float restrictedOrientation = RestrictOrientation(e.RotationDelta);
//float restrictedScale = RestrictScale(e.ScaleDelta);
// 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.DeltaX, e.DeltaY);
}
RestrictCenter();
if (canRotate || canRotateFlick)
{
manipulationProcessor.PivotX = transformedCenter.X;
manipulationProcessor.PivotY = transformedCenter.Y;
manipulationProcessor.PivotRadius = Math.Max(Width, Height) / 2.0f;
}*/
}
/// <summary>
/// Handles the Affine2DManipulationDelta event of the ScatterManipulationProcessor control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Microsoft.Surface.Presentation.Manipulations.Affine2DOperationDeltaEventArgs"/> instance containing the event data.</param>
private void ScatterManipulationProcessor_Affine2DManipulationDelta(object sender, Affine2DOperationDeltaEventArgs e)
{
if (!_overridingScatterViewItem && e.ScaleDelta >= 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.ContactsCaptured.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="Microsoft.Surface.Presentation.Manipulations.Affine2DOperationDeltaEventArgs"/> instance containing the event data.</param>
private void ContentManipulationProcessor_Affine2DManipulationDelta(object sender, Affine2DOperationDeltaEventArgs e)
{
if (GetMaxScale() == 1)
{
return;
}
// The inertia processor can move the content out of bounds.
if (sender == _inertiaProcessor)
{
_translate.X += e.Delta.X;
_translate.Y += e.Delta.Y;
_scale.ScaleX *= e.ScaleDelta;
_scale.ScaleY *= e.ScaleDelta;
return;
}
_spring.Stop(this);
// Determine what scale to apply to the content.
bool returnControlToScatterViewItem = false;
double scaleDelta = 1;
double newScale = _scale.ScaleX * e.ScaleDelta;
if (_content.ActualWidth * newScale >= ActualWidth && newScale <= GetMaxScale())
{
// If the new scale is within the bounds, just use it directly.
scaleDelta = e.ScaleDelta;
}
else if (e.ScaleDelta > 1)
{
// Apply friction to an increasing scale.
scaleDelta = 1 + ((e.ScaleDelta - 1) * _friction);
}
else if (e.ScaleDelta < 1)
{
// Apply friction to a decreasing scale.
scaleDelta = 1 - ((1 - e.ScaleDelta) * _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)
{
ContactsCaptured.ToList().ForEach(c => c.Capture(ScatterViewItem));
_overridingScatterViewItem = false;
}
}
// Move the content.
_translate.X += e.Delta.X;
_translate.Y += e.Delta.Y;
// 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.X;
_translate.X += e.Delta.X * _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.Y;
_translate.Y += e.Delta.Y * _friction;
}
}
void manipulationProcessor_Affine2DManipulationDelta(object sender, Affine2DOperationDeltaEventArgs e)
{
ProcessManipulationInertiaDelta(e);
}
void inertiaProcessorZoom_Affine2DInertiaDelta(object sender, Affine2DOperationDeltaEventArgs e)
{
}
public void OnManipulationDelta(object sender, Affine2DOperationDeltaEventArgs e)
{
particleSystem.particleGridTransform.Angle += e.RotationDelta;
}
private void Rotate(object sender, Affine2DOperationDeltaEventArgs eventArgs)
{
particleSystem.particleGridTransform.Angle += eventArgs.RotationDelta;
foreach (MenuCard card in MenuCardHolder)
{
card.OnManipulationDelta(sender, eventArgs);
}
particleSystem.ToggleControlPanel();
}
/// <summary>
/// Update the changes to inertia processing.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAffine2DInertiaDelta(object sender, Affine2DOperationDeltaEventArgs 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.DeltaX);
// Clamp X
valueX = FlickUtilities.Clamp(valueX, 0, 1);
horizontalScrollBarStateMachine.Value = valueX;
}
if ((Orientation & Orientation.Vertical) != 0)
{
float valueY = verticalScrollBarStateMachine.Value + ConvertFromVerticalScreenToValueSpace(e.DeltaY);
// Clamp Y
valueY = FlickUtilities.Clamp(valueY, 0, 1);
// Update the scrollbars which will update the scroll viewer.
verticalScrollBarStateMachine.Value = valueY;
}
}
