private void OnInertiaCompleted(object sender, Manipulation2DCompletedEventArgs e)
{
// Inertia portion completed.
ClearTimer();
if (_manualComplete && _manualCompleteWithInertia)
{
// Another inertia portion was requested
_lastManipulationBeforeInertia = ConvertDelta(e.Total, _lastManipulationBeforeInertia);
ManipulationInertiaStartingEventArgs inertiaArguments = new ManipulationInertiaStartingEventArgs(
_manipulationDevice,
LastTimestamp,
_currentContainer,
new Point(e.OriginX, e.OriginY),
ConvertVelocities(e.Velocities),
true);
PushEvent(inertiaArguments);
}
else
{
// This is the last event in the sequence.
ManipulationCompletedEventArgs completedArguments = ConvertCompletedArguments(e);
RaiseManipulationCompleted(completedArguments);
}
_inertiaProcessor = null;
}
private void OnManipulationCompleted(object sender, Manipulation2DCompletedEventArgs e)
{
// Manipulation portion completed.
if (_manualComplete && !_manualCompleteWithInertia)
{
// This is the last event in the sequence.
ManipulationCompletedEventArgs completedArguments = ConvertCompletedArguments(e);
RaiseManipulationCompleted(completedArguments);
}
else
{
// This event will configure inertia, which will start after this event.
_lastManipulationBeforeInertia = ConvertDelta(e.Total, null);
ManipulationInertiaStartingEventArgs inertiaArguments = new ManipulationInertiaStartingEventArgs(
_manipulationDevice,
LastTimestamp,
_currentContainer,
new Point(e.OriginX, e.OriginY),
ConvertVelocities(e.Velocities),
false);
PushEvent(inertiaArguments);
}
_manipulationProcessor = null;
}
protected override void OnManipulationInertiaStarting(ManipulationInertiaStartingEventArgs e)
{
base.OnManipulationInertiaStarting(e);
e.TranslationBehavior = new InertiaTranslationBehavior { DesiredDeceleration = 0.0096 };
e.ExpansionBehavior = new InertiaExpansionBehavior { DesiredDeceleration = 0.000096 };
e.Handled = true;
}
void canvas_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
// Decrease the velocity of the Rectangle's movement by
// 10 inches per second every second.
// (10 inches * 96 DIPS per inch / 1000ms^2)
e.TranslationBehavior = new InertiaTranslationBehavior()
{
InitialVelocity = e.InitialVelocities.LinearVelocity,
DesiredDeceleration = 10.0 * 96.0 / (1000.0 * 1000.0)
};
// Decrease the velocity of the Rectangle's resizing by
// 0.1 inches per second every second.
// (0.1 inches * 96 DIPS per inch / (1000ms^2)
e.ExpansionBehavior = new InertiaExpansionBehavior()
{
InitialVelocity = e.InitialVelocities.ExpansionVelocity,
DesiredDeceleration = 0.1 * 96 / 1000.0 * 1000.0
};
// Decrease the velocity of the Rectangle's rotation rate by
// 2 rotations per second every second.
// (2 * 360 degrees / (1000ms^2)
e.RotationBehavior = new InertiaRotationBehavior()
{
InitialVelocity = e.InitialVelocities.AngularVelocity,
DesiredDeceleration = 720 / (1000.0 * 1000.0)
};
e.Handled = true;
}
/// <summary>
/// Step: 5
/// Use the ManipulationInertiaStarting event to set the desired deceleration value for the given manipulation behavior,
/// e.g., ExpansionBehaviour and RotationBehaviour.
/// After the ManipulationInertiaStarting is called,
/// it will call ManipulationDelta until velocity becomes zero.
/// Set initial velocity of the expansion behavior and desired deceleration here.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void centerImageView_ManipulationDelta(object sender, System.Windows.Input.ManipulationInertiaStartingEventArgs e)
{
e.ExpansionBehavior = new InertiaExpansionBehavior()
{
InitialVelocity = e.InitialVelocities.ExpansionVelocity,
DesiredDeceleration = 10.0 * 96.0 / 1000000.0
};
}
/// <summary>
/// Gets ManipulationCompletedEventArgs object out of ManipulationInertiaStartingEventArgs
/// </summary>
private ManipulationCompletedEventArgs GetManipulationCompletedArguments(ManipulationInertiaStartingEventArgs e)
{
Debug.Assert(_lastManipulationBeforeInertia != null);
return(new ManipulationCompletedEventArgs(
_manipulationDevice,
LastTimestamp,
_currentContainer,
new Point(e.ManipulationOrigin.X, e.ManipulationOrigin.Y),
_lastManipulationBeforeInertia,
e.InitialVelocities,
IsInertiaActive));
}
void element_ManipulationInertiaStarting(object sender, System.Windows.Input.ManipulationInertiaStartingEventArgs e)
{
if (this.Element == null)
{
e.Cancel();
return;
}
//start inertia on all gesture
Gestures.ForEach(a => a.ManipulationInertiaStarting(e));
//Debug.WriteLine("OnManipulationInertiaStarting");
double ms = 1000.0;
//base.OnManipulationInertiaStarting(e);
// Decrease the velocity of the Rectangle's movement by
// 10 inches per second every second.
// (10 inches * 96 pixels per inch / 1000ms^2)
//e.TranslationBehavior.DesiredDeceleration = 10 * 96.0 / (1000.0 * 1000.0);
e.TranslationBehavior = new InertiaTranslationBehavior()
{
InitialVelocity = e.InitialVelocities.LinearVelocity,
DesiredDeceleration = 10.0 * 96.0 / (ms * ms)
};
// Decrease the velocity of the Rectangle's resizing by
// 0.1 inches per second every second.
// (0.1 inches * 96 pixels per inch / (1000ms^2)
//e.ExpansionBehavior.DesiredDeceleration = 0.1 * 96 / 1000.0 * 1000.0;
e.ExpansionBehavior = new InertiaExpansionBehavior()
{
InitialVelocity = e.InitialVelocities.ExpansionVelocity,
DesiredDeceleration = 0.1 * 96 / ms * ms
};
// Decrease the velocity of the Rectangle's rotation rate by
// 2 rotations per second every second.
// (2 * 360 degrees / (1000ms^2)
//e.RotationBehavior.DesiredDeceleration = 720 / (1000.0 * 1000.0);
e.RotationBehavior = new InertiaRotationBehavior()
{
InitialVelocity = e.InitialVelocities.AngularVelocity,
DesiredDeceleration = 720 / (ms * ms)
};
e.Handled = true;
}
void Window_InertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
// Decrease the velocity of the Rectangle's movement by
// 10 inches per second every second.
// (10 inches * 96 pixels per inch / 1000ms^2)
e.TranslationBehavior.DesiredDeceleration = 10.0 * 96.0 / (1000.0 * 1000.0);
// Decrease the velocity of the Rectangle's resizing by
// 0.1 inches per second every second.
// (0.1 inches * 96 pixels per inch / (1000ms^2)
e.ExpansionBehavior.DesiredDeceleration = 0.1 * 96 / (1000.0 * 1000.0);
// Decrease the velocity of the Rectangle's rotation rate by
// 2 rotations per second every second.
// (2 * 360 degrees / (1000ms^2)
e.RotationBehavior.DesiredDeceleration = 720 / (1000.0 * 1000.0);
e.Handled = true;
}
/// <summary>
/// Starts the inertia phase based on the results of a ManipulationInertiaStarting event.
/// </summary>
internal void BeginInertia(ManipulationInertiaStartingEventArgs e)
{
if (e.CanBeginInertia())
{
_inertiaProcessor = new InertiaProcessor2D();
_inertiaProcessor.Delta += OnManipulationDelta;
_inertiaProcessor.Completed += OnInertiaCompleted;
e.ApplyParameters(_inertiaProcessor);
// Setup a timer to tick the inertia to completion
_inertiaTimer = new DispatcherTimer();
_inertiaTimer.Interval = TimeSpan.FromMilliseconds(15);
_inertiaTimer.Tick += new EventHandler(OnInertiaTick);
_inertiaTimer.Start();
}
else
{
// This is the last event in the sequence.
ManipulationCompletedEventArgs completedArguments = GetManipulationCompletedArguments(e);
RaiseManipulationCompleted(completedArguments);
PushEventsToDevice();
}
}
private void cProbe_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
DisplayEvent("ManipulationInertiaStarting");
//tbFeedBack.Text += "ManipulationInertiaStarting\r\n";
}
void c_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
e.Handled = true;
}
/// <summary>
/// Handles InerniaStarting event.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event argument.</param>
private void inertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
e.TranslationBehavior.DesiredDeceleration = 10.0 * 96.0 / (1000.0 * 1000.0);
e.Handled = true;
}
protected override void OnManipulationInertiaStarting(ManipulationInertiaStartingEventArgs e)
{
if (_panningInfo != null)
{
if (!_panningInfo.IsPanning && !ForceNextManipulationComplete)
{
// If the inertia starts and we are not scrolling yet, then cancel the manipulation.
e.Cancel();
_panningInfo = null;
}
else
{
e.TranslationBehavior.DesiredDeceleration = PanningDeceleration;
}
e.Handled = true;
}
}
private void startInertiaTranslation(ManipulationInertiaStartingEventArgs e)
{
//TRANSLATION: calculate the overall speedTranslation, depended on the final velocity of the fingers after lifting from the sim object
double speedTranslation = e.InitialVelocities.LinearVelocity.Length * App.DpiFactor; //* 10.416; //the initial speedTranslation (depending on the dpi of the screen --> Magic Number for dpi of 96: 10.416 inch)
double movementTimeInMS = this.ProtoDefinition.MoveManipulation.MovementTime * 1000.0;
double msTillDistanceIsReached = (2 * this.ProtoDefinition.MoveManipulation.TravelDistance * App.UnitConversionFactor) / speedTranslation; //fixed distance
//double distanceTraveledOverTime = (speedTranslation * movementTimeInMS) / 2; //fixed time
//TRANSLATION: Calculate the deceleration delta
switch (this.ProtoDefinition.MoveManipulation.FlickingBehavior)
{
case MoveManipulation.FLICK_MOVE_OVER_TIME: this.inertiaTranslationDecelDelta = (speedTranslation / movementTimeInMS) / App.DpiFactor; break; //equivalent formula: ((2 * distanceTraveledOverTime) / Math.Pow(movementTimeInMS, 2.0)) / App.DpiFactor; break;
case MoveManipulation.FLICK_MOVE_OVER_DISTANCE: this.inertiaTranslationDecelDelta = (speedTranslation / msTillDistanceIsReached) / App.DpiFactor; break; //(((speedTranslation * speedTranslation) / (2 * this.ProtoDefinition.MoveManipulation.TravelDistance)) / App.DpiFactor) / (1000.0 * 1000.0); break;
case MoveManipulation.FLICK_MOVE_CONSTANT:
default: this.inertiaTranslationDecelDelta = ((this.ProtoDefinition.MoveManipulation.ConstantDeceleration * App.UnitConversionFactor) / App.DpiFactor) / (1000.0 * 1000.0); break;
}
this.inertiaTranslationVector = new Vector(e.InitialVelocities.LinearVelocity.X, e.InitialVelocities.LinearVelocity.Y);
//Debug.log("Translation Inertia started; v_t = " + this.inertiaTranslationVector + "; decel = " + this.inertiaTranslationDecelDelta);
//go go power rangers!
this.IsInertialTranslation = true;
}
private void startInertiaRotation(ManipulationInertiaStartingEventArgs e)
{
//ROTATION: speed and rotation centers, initial angulr velocity is measured in deg/s (NOT in rad!)
double speedRotation = Math.Abs(e.InitialVelocities.AngularVelocity);
double rotationTimeInMS = this.ProtoDefinition.RotateManipulation.RotationTime * 1000.0;
double msTillAngleIsReached = (2 * this.ProtoDefinition.RotateManipulation.RotationToAngle) / speedRotation; //fixed distance
//double angleTraveledOverTime = (speedRotation * rotationTimeInMS) / 2; //fixed angular distance
//ROTATION: deceleration delta
switch (this.ProtoDefinition.RotateManipulation.FlickingBehavior)
{
case RotateManipulation.FLICK_ROTATE_OVER_TIME: this.inertiaRotationDecelDelta = speedRotation / rotationTimeInMS; break; //equivalent formula: (2 * angleTraveledOverTime) / Math.Pow(rotationTimeInMS, 2.0); break;
case RotateManipulation.FLICK_ROTATE_TO_ANGLE: this.inertiaRotationDecelDelta = speedRotation / msTillAngleIsReached; break; //fixed angular distance
case RotateManipulation.FLICK_ROTATE_CONSTANT:
default: this.inertiaRotationDecelDelta = this.ProtoDefinition.RotateManipulation.ConstantDeceleration / (1000.0 * 1000.0); break; //fixed deceleration in deg per seconds square
}
this.inertiaRotationAngle = Math.Abs(e.InitialVelocities.AngularVelocity);
this.inertiaRotationDirection = Math.Sign(e.InitialVelocities.AngularVelocity);
//and start..
this.IsInertialRotation = true;
}
/// <summary>
/// Gets ManipulationCompletedEventArgs object out of ManipulationInertiaStartingEventArgs
/// </summary>
private ManipulationCompletedEventArgs GetManipulationCompletedArguments(ManipulationInertiaStartingEventArgs e)
{
Debug.Assert(_lastManipulationBeforeInertia != null);
return new ManipulationCompletedEventArgs(
_manipulationDevice,
LastTimestamp,
_currentContainer,
new Point(e.ManipulationOrigin.X, e.ManipulationOrigin.Y),
_lastManipulationBeforeInertia,
e.InitialVelocities,
IsInertiaActive);
}
private void OnInertiaCompleted(object sender, Manipulation2DCompletedEventArgs e)
{
// Inertia portion completed.
ClearTimer();
if (_manualComplete && _manualCompleteWithInertia)
{
// Another inertia portion was requested
_lastManipulationBeforeInertia = ConvertDelta(e.Total, _lastManipulationBeforeInertia);
ManipulationInertiaStartingEventArgs inertiaArguments = new ManipulationInertiaStartingEventArgs(
_manipulationDevice,
LastTimestamp,
_currentContainer,
new Point(e.OriginX, e.OriginY),
ConvertVelocities(e.Velocities),
true);
PushEvent(inertiaArguments);
}
else
{
// This is the last event in the sequence.
ManipulationCompletedEventArgs completedArguments = ConvertCompletedArguments(e);
RaiseManipulationCompleted(completedArguments);
}
_inertiaProcessor = null;
}
public virtual void OnManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e) { }
/// <summary>
/// Manipulation inertia starting postprocess handler
/// </summary>
/// <param name="e">Event args</param>
public virtual void PostprocessManipulationInertiaStarting(ManipulationInertiaStartingEventArgs e) { }
private static void OnManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
e.TranslationBehavior.DesiredDeceleration = 25 * 96.0 / (1000.0 * 1000.0);
}
private void PostProcessInput(object sender, ProcessInputEventArgs e)
{
InputEventArgs inputEventArgs = e.StagingItem.Input;
if (inputEventArgs.Device == this)
{
RoutedEvent routedEvent = inputEventArgs.RoutedEvent;
if (routedEvent == Manipulation.ManipulationDeltaEvent)
{
ManipulationDeltaEventArgs deltaEventArgs = inputEventArgs as ManipulationDeltaEventArgs;
if (deltaEventArgs != null)
{
// During deltas, see if panning feedback is needed on the window
ManipulationDelta unusedManipulation = deltaEventArgs.UnusedManipulation;
_manipulationLogic.RaiseBoundaryFeedback(unusedManipulation, deltaEventArgs.RequestedComplete);
_manipulationLogic.PushEventsToDevice();
// If a Complete is requested, then pass it along to the manipulation processor
if (deltaEventArgs.RequestedComplete)
{
_manipulationLogic.Complete(/* withInertia = */ deltaEventArgs.RequestedInertia);
_manipulationLogic.PushEventsToDevice();
}
else if (deltaEventArgs.RequestedCancel)
{
Debug.Assert(!deltaEventArgs.IsInertial);
OnManipulationCancel();
}
}
}
else if (routedEvent == Manipulation.ManipulationStartingEvent)
{
ManipulationStartingEventArgs startingEventArgs = inputEventArgs as ManipulationStartingEventArgs;
if (startingEventArgs != null && startingEventArgs.RequestedCancel)
{
OnManipulationCancel();
}
}
else if (routedEvent == Manipulation.ManipulationStartedEvent)
{
ManipulationStartedEventArgs startedEventArgs = inputEventArgs as ManipulationStartedEventArgs;
if (startedEventArgs != null)
{
if (startedEventArgs.RequestedComplete)
{
// If a Complete is requested, pass it along to the manipulation processor
_manipulationLogic.Complete(/* withInertia = */ false);
_manipulationLogic.PushEventsToDevice();
}
else if (startedEventArgs.RequestedCancel)
{
OnManipulationCancel();
}
else
{
// Start ticking to produce delta events
ResumeAllTicking(); // Resumes the ticking of all the suspended devices on the thread
StartTicking(); // Ensures that we continue ticking or restart ticking for this device
}
}
}
else if (routedEvent == Manipulation.ManipulationInertiaStartingEvent)
{
// Switching from using rendering for ticking to a timer at lower priority (handled by ManipulationLogic)
StopTicking();
// Remove all the manipulators so that we dont re-start manipulations accidentally
RemoveAllManipulators();
// Initialize inertia
ManipulationInertiaStartingEventArgs inertiaEventArgs = inputEventArgs as ManipulationInertiaStartingEventArgs;
if (inertiaEventArgs != null)
{
if (inertiaEventArgs.RequestedCancel)
{
OnManipulationCancel();
}
else
{
_manipulationLogic.BeginInertia(inertiaEventArgs);
}
}
}
else if (routedEvent == Manipulation.ManipulationCompletedEvent)
{
_manipulationLogic.OnCompleted();
ManipulationCompletedEventArgs completedEventArgs = inputEventArgs as ManipulationCompletedEventArgs;
if (completedEventArgs != null)
{
if (completedEventArgs.RequestedCancel)
{
Debug.Assert(!completedEventArgs.IsInertial);
OnManipulationCancel();
}
else if (!(completedEventArgs.IsInertial && _ticking))
{
// Remove the manipulation device only if
// another manipulation didnot start
OnManipulationComplete();
}
}
}
else if (routedEvent == Manipulation.ManipulationBoundaryFeedbackEvent)
{
ManipulationBoundaryFeedbackEventArgs boundaryEventArgs = inputEventArgs as ManipulationBoundaryFeedbackEventArgs;
if (boundaryEventArgs != null)
{
_compensateForBoundaryFeedback = boundaryEventArgs.CompensateForBoundaryFeedback;
}
}
}
}
/// <summary>
/// Handles the ManipulationInertiaStarting event of the River control. Sets inertia properties.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Input.ManipulationInertiaStartingEventArgs"/> instance containing the event data.</param>
private void River_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
e.TranslationBehavior.InitialVelocity = e.InitialVelocities.LinearVelocity;
e.TranslationBehavior.DesiredDeceleration = (20.0 * 96.0) / 1000000.0;
}
/// <summary>
/// Starts the inertia phase based on the results of a ManipulationInertiaStarting event.
/// </summary>
internal void BeginInertia(ManipulationInertiaStartingEventArgs e)
{
if (e.CanBeginInertia())
{
_inertiaProcessor = new InertiaProcessor2D();
_inertiaProcessor.Delta += OnManipulationDelta;
_inertiaProcessor.Completed += OnInertiaCompleted;
e.ApplyParameters(_inertiaProcessor);
// Setup a timer to tick the inertia to completion
_inertiaTimer = new DispatcherTimer();
_inertiaTimer.Interval = TimeSpan.FromMilliseconds(15);
_inertiaTimer.Tick += new EventHandler(OnInertiaTick);
_inertiaTimer.Start();
}
else
{
// This is the last event in the sequence.
ManipulationCompletedEventArgs completedArguments = GetManipulationCompletedArguments(e);
RaiseManipulationCompleted(completedArguments);
PushEventsToDevice();
}
}
/// <summary>
/// Delegate the inertia implementation to the Manipulation objects
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Canvas_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
//getting the original Manipulation Origin Point
this.inertiaManipulationOrigin = new Point()
{
X = e.ManipulationOrigin.X,
Y = e.ManipulationOrigin.Y
};
//if inertia is activated setup the necessary variables
if (this.ProtoDefinition.MoveManipulation.FlickingBehavior != MoveManipulation.FLICK_NONE)
{
this.startInertiaTranslation(e);
}
if (this.ProtoDefinition.RotateManipulation.FlickingBehavior != RotateManipulation.FLICK_NONE)
{
this.startInertiaRotation(e);
}
if (this.ProtoDefinition.ScaleManipulation.FlickingBehavior != ScaleManipulation.FLICK_NONE)
{
this.startInertiaScaling(e);
}
e.Handled = true;
}
private void OnManipulationCompleted(object sender, Manipulation2DCompletedEventArgs e)
{
// Manipulation portion completed.
if (_manualComplete && !_manualCompleteWithInertia)
{
// This is the last event in the sequence.
ManipulationCompletedEventArgs completedArguments = ConvertCompletedArguments(e);
RaiseManipulationCompleted(completedArguments);
}
else
{
// This event will configure inertia, which will start after this event.
_lastManipulationBeforeInertia = ConvertDelta(e.Total, null);
ManipulationInertiaStartingEventArgs inertiaArguments = new ManipulationInertiaStartingEventArgs(
_manipulationDevice,
LastTimestamp,
_currentContainer,
new Point(e.OriginX, e.OriginY),
ConvertVelocities(e.Velocities),
false);
PushEvent(inertiaArguments);
}
_manipulationProcessor = null;
}
private void startInertiaScaling(ManipulationInertiaStartingEventArgs e)
{
Debug.log("scale: " + e.InitialVelocities.ExpansionVelocity + ", l: " + e.InitialVelocities.ExpansionVelocity.Length);
double speedScaling = e.InitialVelocities.ExpansionVelocity.Length * App.DpiFactor; //the initial scaling speed
double scalingTimeInMS = this.ProtoDefinition.ScaleManipulation.ScalingTime * 1000.0;
double msTillFactorIsReached = (2 * this.ProtoDefinition.ScaleManipulation.ScaleDistance * App.UnitConversionFactor) / speedScaling; //fixed distance
//double distanceTraveledOverTime = (speedTranslation * movementTimeInMS) / 2; //fixed time
//TRANSLATION: Calculate the deceleration delta
switch (this.ProtoDefinition.ScaleManipulation.FlickingBehavior)
{
case ScaleManipulation.FLICK_SCALE_OVER_TIME: this.inertiaScalingDecelDelta = (speedScaling / scalingTimeInMS) / App.DpiFactor; break; //equivalent formula: ((2 * distanceTraveledOverTime) / Math.Pow(movementTimeInMS, 2.0)) / App.DpiFactor; break;
case ScaleManipulation.FLICK_SCALE_DISTANCE: this.inertiaScalingDecelDelta = (speedScaling / msTillFactorIsReached) / App.DpiFactor; break; //(((speedTranslation * speedTranslation) / (2 * this.ProtoDefinition.ScaleManipulation.ScaleDistance)) / App.DpiFactor) / (1000.0 * 1000.0); break;
case ScaleManipulation.FLICK_SCALE_CONSTANT:
default: this.inertiaScalingDecelDelta = ((this.ProtoDefinition.ScaleManipulation.ConstantDeceleration * App.UnitConversionFactor) / App.DpiFactor) / (1000.0 * 1000.0); break;
}
this.inertiaScalingVector = new Vector(e.InitialVelocities.ExpansionVelocity.X, e.InitialVelocities.ExpansionVelocity.Y);
//Debug.log("Scaling speed length: " + speedScaling);
//Debug.log("Scaling Inertia Started; v_s = " + this.inertiaScalingVector + "; decel = " + this.inertiaScalingDecelDelta + "; duration = " + msTillFactorIsReached + "ms");
this.IsInertialScaling = true;
}
protected override void OnManipulationInertiaStarting(ManipulationInertiaStartingEventArgs e)
{
base.OnManipulationInertiaStarting(e);
e.TranslationBehavior.DesiredDeceleration = 0.001;
e.RotationBehavior.DesiredDeceleration = 0.01;
e.ExpansionBehavior.DesiredDeceleration = 0.01;
}
private static void OnStaticManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
Window window = sender as Window;
if (window != null)
{
// Transitioning from direct manipulation to inertia, animate the window
// back to its original position.
window.EndPanningFeedback(true);
}
}
public virtual void ManipulationInertiaStarting(System.Windows.Input.ManipulationInertiaStartingEventArgs e)
{
}
void ManipulationElement_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e) {
foreach (var m in mouseProcessors) {
if (e.Handled)
break;
m.PreprocessManipulationInertiaStarting(e);
}
if (!e.Handled)
defaultMouseProcessor.OnManipulationInertiaStarting(sender, e);
foreach (var m in mouseProcessors)
m.PostprocessManipulationInertiaStarting(e);
}
private void cTimeLine_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
if (!Timeline.CanChangeTimeInterval) return;
if (e.InitialVelocities.LinearVelocity.X < -1 || e.InitialVelocities.LinearVelocity.X > 1)
e.TranslationBehavior = new InertiaTranslationBehavior
{
InitialVelocity = e.InitialVelocities.LinearVelocity,
DesiredDeceleration = Deceleration
};
e.Handled = true;
}
/// <summary>
/// Delegate the inertia implementation to the Manipulation objects
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Canvas_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
//this.ProtoDefinition.MoveManipulation.InertiaImplementation(sender, e);
//this.ProtoDefinition.ScaleManipulation.InertiaImplementation(sender, e);
//this.ProtoDefinition.RotateManipulation.InertiaImplementation(sender, e);
e.Handled = true;
}
protected virtual void OnManipulationInertiaStarting(ManipulationInertiaStartingEventArgs e);
protected override void OnManipulationInertiaStarting(ManipulationInertiaStartingEventArgs e)
{
base.OnManipulationInertiaStarting(e);
e.TranslationBehavior = new InertiaTranslationBehavior { DesiredDeceleration = 0.0096 };
e.ExpansionBehavior = new InertiaExpansionBehavior { DesiredDeceleration = 0.000096 };
if (!_hasManipulationDelta)
{
PickerPoint = new Point((e.ManipulationOrigin.X + ZoomableCanvasOffset.X) / Scale, (e.ManipulationOrigin.Y + ZoomableCanvasOffset.Y) / Scale);
}
_hasManipulationDelta = false;
e.Handled = true;
}
private void ViewGrid_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
//Trägheitseffekte für die Touch-Manipulation des Raumplans
//siehe auch http://msdn.microsoft.com/de-de/library/ee649090.aspx#Y1710
// Decrease the velocity of the Rectangle's movement by
// 10 inches per second every second.
// (10 inches * 96 pixels per inch / 1000ms^2)
e.TranslationBehavior.DesiredDeceleration = 10.0 * 96.0 / (1000.0 * 1000.0);
// Decrease the velocity of the Rectangle's resizing by
// 0.1 inches per second every second.
// (0.1 inches * 96 pixels per inch / (1000ms^2)
e.ExpansionBehavior.DesiredDeceleration = 0.1 * 96 / (1000.0 * 1000.0);
// Decrease the velocity of the Rectangle's rotation rate by
// 2 rotations per second every second.
// (2 * 360 degrees / (1000ms^2)
e.RotationBehavior.DesiredDeceleration = 720 / (1000.0 * 1000.0);
e.Handled = true;
}
void DramControl_ManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
{
e.TranslationBehavior.DesiredDeceleration = 0.002;
}
void BeginInertia(object sender, ManipulationInertiaStartingEventArgs args) {
args.TranslationBehavior.DesiredDeceleration = DECELERATION;
}
private void Window_ManipulationInertiaStarting_1(object sender, ManipulationInertiaStartingEventArgs e)
{
LogMessage("Total X: " + totalX);
LogMessage("Total Y: " + totalY);
commander.ChangeDirection((short)totalX, (short)totalY);
totalX = 0;
totalY = 0;
//((MatrixTransform)FlickPad.RenderTransform).Matrix = origin;
}
public void OnManipulationInertiaStarting(object sender, System.Windows.Input.ManipulationInertiaStartingEventArgs e)
{
Console.WriteLine("ViewerContext got manipulation inertia started event.");
}
