private void SwipeableTextBlock_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (e.IsInertial && !_isSwiped)
{
var swipedDistance = e.Cumulative.Translation.X;
if (Math.Abs(swipedDistance) <= 2)
{
return;
}
if (swipedDistance > 0)
{
if (currentWein != 0)
{
currentWein--;
}
else
{
currentWein = WeinList.Count - 1;
}
Load_Wine(currentWein);
}
else
{
if (currentWein != WeinList.Count - 1)
{
currentWein++;
}
else
{
currentWein = 0;
}
Load_Wine(currentWein);
}
_isSwiped = true;
}
}
private void _rectTopLeft_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (ContentIsTextbox == true)
{
MoveAndRestrain(e);
}
else
{
// Get top left point
GeneralTransform gt = this.TransformToVisual((Panel)this.Parent);
Point TopLeftPoint = gt.TransformPoint(new Point(0, 0));
// Set these to represent the edges
double left = TopLeftPoint.X;
double top = TopLeftPoint.Y;
// Combine the adjustable edges with the movement value
double leftAdjust = left + e.Delta.Translation.X;
double topAdjust = top + e.Delta.Translation.Y;
// Set these to use for restricting the minimum size
double yadjust = this.ActualHeight - e.Delta.Translation.Y;
double xadjust = this.ActualWidth - e.Delta.Translation.X;
// Allow adjustment within restrictions
if ((leftAdjust >= 0) && (xadjust >= minWidth))
{
transform_myControl.TranslateX += e.Delta.Translation.X;
this.Width = xadjust;
}
if ((topAdjust >= 0) && (yadjust >= minHeight))
{
transform_myControl.TranslateY += e.Delta.Translation.Y;
this.Height = yadjust;
}
}
}
private void OnManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
double deltaX = e.Delta.Translation.X;
if (this.ActualWidth > this.ItemWidth * _panel.ItemsCount)
{
e.Complete();
e.Handled = true;
return;
}
if (this.Position + deltaX > this.ItemWidth / 2.5)
{
e.Complete();
e.Handled = true;
return;
}
if (this.Position + deltaX < -(this.ItemWidth * _panel.ItemsCount - this.ActualWidth) - this.ItemWidth / 2.5)
{
e.Complete();
e.Handled = true;
return;
}
int itemsPerThird = (int)Math.Ceiling(this.ActualWidth / this.ItemWidth);
if (Math.Abs(e.Cumulative.Translation.X) >= this.ItemWidth * itemsPerThird)
{
e.Complete();
}
else
{
_panel.TranslateDeltaX(deltaX);
}
e.Handled = true;
}
private void HandlePanManipulation(ManipulationDeltaRoutedEventArgs args)
{
var rectangle = new RadRect(args.Container.RenderSize.Width, args.Container.RenderSize.Height);
var point = args.Position;
var x = point.X;
var y = point.Y;
var dx = args.Delta.Translation.X;
var dy = args.Delta.Translation.Y;
var manipulationStartPointInside = rectangle.Contains(x, y);
var manipulationEndPointInside = rectangle.Contains(x + dx, y + dy);
if (!manipulationStartPointInside && !manipulationEndPointInside)
{
// pointer was outside during the whole manipulation, nothing should happen
return;
}
if (manipulationEndPointInside)
{
// at the end the pointer is inside the container => handle point manipulation
this.HandlePointManipulation(new Point(x + dx, y + dx));
}
else
{
// the pointer has left the contained during the manipulation - should determine the direction
var manipulationLeavingPointDirection = this.GetManipulationDirection(dy, dx, y, x, rectangle);
this.HandleManipulationLeavesRating(manipulationLeavingPointDirection);
if (this.freezeDisplayValue)
{
this.UpdateFillRatio();
}
}
}
private void Handle_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
var transform = (sender as Grid).RenderTransform as CompositeTransform;
var translate = (LeftHandle.RenderTransform as CompositeTransform).TranslateX;
double translateX = transform.TranslateX + e.Delta.Translation.X;
if (transform == LeftHandleTransform)
{
if (translateX < 0 || ((translateX + HandleSize) > RightHandleTransform.TranslateX))
{
return;
}
transform.TranslateX = translateX;
if (MinValueChanged != null)
{
MinValueChanged(this, new ValueChangedEventArgs(Min));
}
}
else if (transform == RightHandleTransform)
{
if ((translateX + HandleSize) > Width || (translateX < LeftHandleTransform.TranslateX + HandleSize))
{
return;
}
transform.TranslateX = translateX;
if (MaxValueChanged != null)
{
MaxValueChanged(this, new ValueChangedEventArgs(Max));
}
}
UpdateInner();
}
//</SnippetDeclareSourceRect>
//<SnippetManipulationDelta>
private void _mediaPlayerElement_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (e.Delta.Scale != 1)
{
var halfWidth = _sourceRect.Width / 2;
var halfHeight = _sourceRect.Height / 2;
var centerX = _sourceRect.X + halfWidth;
var centerY = _sourceRect.Y + halfHeight;
var scale = e.Delta.Scale;
var newHalfWidth = (_sourceRect.Width * e.Delta.Scale) / 2;
var newHalfHeight = (_sourceRect.Height * e.Delta.Scale) / 2;
if (centerX - newHalfWidth > 0 && centerX + newHalfWidth <= 1.0 &&
centerY - newHalfHeight > 0 && centerY + newHalfHeight <= 1.0)
{
_sourceRect.X = centerX - newHalfWidth;
_sourceRect.Y = centerY - newHalfHeight;
_sourceRect.Width *= e.Delta.Scale;
_sourceRect.Height *= e.Delta.Scale;
}
}
else
{
var translateX = -1 * e.Delta.Translation.X / _mediaPlayerElement.ActualWidth;
var translateY = -1 * e.Delta.Translation.Y / _mediaPlayerElement.ActualHeight;
if (_sourceRect.X + translateX >= 0 && _sourceRect.X + _sourceRect.Width + translateX <= 1.0 &&
_sourceRect.Y + translateY >= 0 && _sourceRect.Y + _sourceRect.Height + translateY <= 1.0)
{
_sourceRect.X += translateX;
_sourceRect.Y += translateY;
}
}
_mediaPlayer.PlaybackSession.NormalizedSourceRect = _sourceRect;
}
private void LayoutRoot_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (e.IsInertial)
{
e.Complete();
return;
}
var delta = (float)e.Delta.Translation.X;
var width = (float)ActualWidth;
var current = -(_selectedIndex * width);
var previous = current + width;
var next = current - width;
var maximum = next;
var minimum = previous;
if (_selectedIndex == 0)
{
minimum = 0;
}
else if (_selectedIndex == 5)
{
maximum = current;
}
var offset = _layoutVisual.Offset;
offset.X = Math.Max(maximum, Math.Min(minimum, offset.X + delta));
var position = Math.Max(maximum, Math.Min(minimum, offset.X)) / width;
position += _selectedIndex;
_layoutVisual.Offset = offset;
_renderer?.SetScroll(-position);
}
private void ImageThumb_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (e.Delta.Scale != 1.0)
{
double width;
double height;
var imageScale = m_imageRectangle.Width / m_imageRectangle.Height;
if (m_thumbsRectangle.Width / m_thumbsRectangle.Height < imageScale)
{
height = Math.Max(m_imageRectangle.Height * e.Delta.Scale, m_thumbsRectangle.Height);
width = height * imageScale;
}
else
{
width = Math.Max(m_imageRectangle.Width * e.Delta.Scale, m_thumbsRectangle.Width);
height = width / imageScale;
}
m_imageRectangle.X = Clamp(m_imageRectangle.Left + (m_imageRectangle.Width - width) / 2.0, m_thumbsRectangle.Right - width, m_thumbsRectangle.Left);
m_imageRectangle.Y = Clamp(m_imageRectangle.Top + (m_imageRectangle.Height - height) / 2.0, m_thumbsRectangle.Bottom - height, m_thumbsRectangle.Top);
m_imageRectangle.Width = width;
m_imageRectangle.Height = height;
UpdateCropRectangle(false);
e.Handled = true;
}
else if (e.Delta.Translation.X != 0.0 || e.Delta.Translation.Y != 0.0)
{
m_imageRectangle.X = Clamp(m_imageRectangle.Left + e.Delta.Translation.X, m_thumbsRectangle.Right - m_imageRectangle.Width, m_thumbsRectangle.Left);
m_imageRectangle.Y = Clamp(m_imageRectangle.Top + e.Delta.Translation.Y, m_thumbsRectangle.Bottom - m_imageRectangle.Height, m_thumbsRectangle.Top);
UpdateCropRectangle(false);
e.Handled = true;
}
}
protected override void OnManipulationDelta(ManipulationDeltaRoutedEventArgs args)
{
manipulationManager.AccumulateDelta(args.Position, args.Delta);
matrixXform.Matrix = manipulationManager.Matrix;
// Make this the entire transform to date
//matrixXform.Matrix = xformGroup.Value;
// Use that to transform the Position property
//Point center = matrixXform.TransformPoint(args.Position);
// That becomes the center of the new incremental transform
//compositeXform.CenterX = center.X;
//compositeXform.CenterY = center.Y;
// Set the other properties
//compositeXform.TranslateX = args.Delta.Translation.X;
//compositeXform.TranslateY = args.Delta.Translation.Y;
//compositeXform.ScaleX = args.Delta.Scale;
//compositeXform.ScaleY = args.Delta.Scale;
//compositeXform.Rotation = args.Delta.Rotation;
base.OnManipulationDelta(args);
}
private void SourceImage_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
var diffPos = e.Delta.Translation;
var inverseImageTransform = _imageTransform.Inverse;
if (inverseImageTransform != null)
{
var startPoint = new Point(_startX - diffPos.X, _startY - diffPos.Y);
var endPoint = new Point(_endX - diffPos.X, _endY - diffPos.Y);
if (_restrictedSelectRect.IsSafePoint(startPoint) && _restrictedSelectRect.IsSafePoint(endPoint))
{
var selectedRect = new Rect(startPoint, endPoint);
if ((selectedRect.Width - MinSelectSize.Width) < -0.001 || (selectedRect.Height - MinSelectSize.Height) < -0.001)
{
return;
}
var movedRect = inverseImageTransform.TransformBounds(selectedRect);
movedRect.Intersect(_restrictedCropRect);
_currentCroppedRect = movedRect;
UpdateImageLayout();
}
}
}
private void Select_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
//System.Diagnostics.Debug.WriteLine("X :: " + e.Delta.Translation.X);
//System.Diagnostics.Debug.WriteLine("Y :: " + e.Delta.Translation.Y);
//dragTranslation.X += e.Delta.Translation.X;
// dragTranslation.Y += e.Delta.Translation.Y;
var translate = (TranslateTransform)Select.RenderTransform;
var newPosX = Canvas.GetLeft(Select) + translate.X + e.Delta.Translation.X;
var newPosY = Canvas.GetTop(Select) + translate.Y + e.Delta.Translation.Y;
if (!isBoundary(newPosX, CanvasRoot.ActualWidth - Select.ActualWidth, 0))
{
translate.X += e.Delta.Translation.X;
}
if (!isBoundary(newPosY, CanvasRoot.ActualHeight - Select.ActualHeight, 0))
{
translate.Y += e.Delta.Translation.Y;
}
}
private void Canvas_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (Math.Abs(e.Cumulative.Translation.X) >= this.ActualWidth)
{
e.Complete();
return;
}
if (_firstItem != null)
{
((CompositeTransform)_firstItem.RenderTransform).TranslateX += e.Delta.Translation.X;
}
if (_secondItem != null)
{
((CompositeTransform)_secondItem.RenderTransform).TranslateX += e.Delta.Translation.X;
}
if (_thirdItem != null)
{
((CompositeTransform)_thirdItem.RenderTransform).TranslateX += e.Delta.Translation.X;
}
}
private void _popup_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
var Host = (FrameworkElement)this.Parent;
var _translatetransform = _popup.RenderTransform as CompositeTransform;
var enddelta = _translatetransform.TranslateY + e.Delta.Translation.Y;
if (enddelta >= Host.ActualHeight)
{
_translatetransform.TranslateY = Host.ActualHeight;
}
else if (double.IsNaN(PopupHeight) && enddelta < 100)
{
_translatetransform.TranslateY = 100;
}
else if (enddelta < (Host.ActualHeight - PopupHeight))
{
_translatetransform.TranslateY = (Host.ActualHeight - PopupHeight);
}
else
{
_translatetransform.TranslateY += e.Delta.Translation.Y;
}
}
private void ScrollViewer_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (_mainScrollViewer == null)
{
return;
}
var verticalOffset = _mainScrollViewer.VerticalOffset;
var movement = e.Cumulative.Translation.Y; // *e.Velocities.Linear.Y;
var newVerticalOffset = verticalOffset - movement;
/*
* Debug.WriteLine(string.Empty);
* Debug.WriteLine(movement);
* Debug.WriteLine("Vertical offset:" + verticalOffset);
* Debug.WriteLine("Y translation:" + e.Delta.Translation.Y);
* Debug.WriteLine("Velocity:" + e.Velocities.Linear.Y);
* Debug.WriteLine("Movement:" + movement);
* Debug.WriteLine("New vertical offset:" + newVerticalOffset);
*/
_mainScrollViewer.ChangeView(null, newVerticalOffset, null, false);
OnManipulationDelta(e);
}
// Process the change resulting from a manipulation
void ManipulateMe_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
// If the reset button has been pressed, mark the manipulation as completed
if (forceManipulationsToEnd)
{
e.Complete();
return;
}
previousTransform.Matrix = transforms.Value;
// Get center point for rotation
Point center = previousTransform.TransformPoint(new Point(e.Position.X, e.Position.Y));
deltaTransform.CenterX = center.X;
deltaTransform.CenterY = center.Y;
// Look at the Delta property of the ManipulationDeltaRoutedEventArgs to retrieve
// the rotation, scale, X, and Y changes
deltaTransform.Rotation = e.Delta.Rotation;
deltaTransform.TranslateX = e.Delta.Translation.X;
deltaTransform.TranslateY = e.Delta.Translation.Y;
}
protected virtual async void OnManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
transformTranslation.X += e.Delta.Translation.X;
transformTranslation.Y += e.Delta.Translation.Y;
transformRotation += e.Delta.Rotation;
transformScale *= e.Delta.Scale;
if (!transformPending)
{
transformPending = true;
await Dispatcher.RunIdleAsync(a =>
{
TransformMap(e.Position, transformTranslation, transformRotation, transformScale);
transformPending = false;
transformTranslation.X = 0d;
transformTranslation.Y = 0d;
transformRotation = 0d;
transformScale = 1d;
});
}
}
private void Grip_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
var detail = Children[0];
var master = Children[1] as FrameworkElement;
var grip = Children[2];
var newWidth = master.ActualWidth + e.Cumulative.Translation.X;
var newRatio = (newWidth < columnMinimalWidthLeft / 2)
? 0
: newWidth / ActualWidth;
if (newRatio == 0 && _allowCompact)
{
newWidth = columnCompactWidthLeft;
}
else
{
newWidth = CountDialogsWidthFromRatio(ActualWidth, newRatio);
}
grip.Arrange(new Rect(newWidth, 0, 12, ActualHeight));
gripWidthRatio = newRatio;
}
private void Manipulator_OnManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
//if (_isResizing)
//{
// //Width += e.Delta.Translation.X;
// //Height += e.Delta.Translation.Y;
//}
//else
{
CTransform.TranslateX += e.Delta.Translation.X;
CTransform.TranslateY += e.Delta.Translation.Y;
try
{
SettingsHelper.Settings.LockControlX = CTransform.TranslateX;
SettingsHelper.Settings.LockControlY = CTransform.TranslateY;
}
catch { }
//Canvas.SetLeft(this, Canvas.GetLeft(this) + e.Delta.Translation.X);
//Canvas.SetTop(this, Canvas.GetTop(this) + e.Delta.Translation.Y);
}
}
private void OnManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (_translate == null)
{
return;
}
_translate.X += e.Delta.Translation.X;
_translate.Y += e.Delta.Translation.Y;
var currentPosition = (_floatingElement).TransformToVisual(ParentPage).TransformPoint(new Point(0, 0));
var currentXPosition = currentPosition.X;
var currentYPosition = currentPosition.Y;
_isOverLocation = LocationCommandMappings
.FirstOrDefault(lcm =>
lcm.Location != null &&
(lcm.Location.Position.X <= currentXPosition && currentXPosition <= (lcm.Location.Position.X + lcm.Location.Size.Width)) &&
(lcm.Location.Position.Y <= currentYPosition && currentYPosition <= (lcm.Location.Position.Y + lcm.Location.Size.Height)));
e.Handled = true;
}
private void Handle_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
Rectangle handle = sender as Rectangle; // Get the handle being moved
Point allowedDeleta = (Point)handle.Tag; // Get the allowed X/Y deltas for this handle
if (allowedDeleta.X != 0)
{
double left = _gaugeItem.GaugeLeft + e.Delta.Translation.X * e.Delta.Scale;
_gaugeItem.GaugeLeft = Math.Max(0, left);
double width = _gaugeItem.GaugeWidth + e.Delta.Translation.X * e.Delta.Scale * allowedDeleta.X;
_gaugeItem.GaugeWidth = Math.Max(10, width);
}
if (allowedDeleta.Y != 0)
{
double top = _gaugeItem.GaugeTop + e.Delta.Translation.Y * e.Delta.Scale;
_gaugeItem.GaugeTop = Math.Max(0, top);
double height = _gaugeItem.GaugeHeight + e.Delta.Translation.Y * e.Delta.Scale * allowedDeleta.Y;
_gaugeItem.GaugeHeight = Math.Max(10, height);
}
}
private void GenericMediaDataElement_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
// Don't allow user to pan if no zoom has been applied.
if (MediaScrollViewer.ZoomFactor == 1.0f)
{
return;
}
MediaTransform.TranslateX += e.Delta.Translation.X / MediaScrollViewer.ZoomFactor;
MediaTransform.TranslateY += e.Delta.Translation.Y / MediaScrollViewer.ZoomFactor;
var elementBounds = MediaTransform.TransformBounds(new Rect(0.0, 0.0, GenericMediaDataElement.ActualWidth, GenericMediaDataElement.ActualHeight));
var containerRect = new Rect(0.0, 0.0, MediaScrollViewer.ViewportWidth, MediaScrollViewer.ViewportHeight);
var isPartiallyVisible = containerRect.Contains(new Point(elementBounds.Left, elementBounds.Top)) || containerRect.Contains(new Point(elementBounds.Right, elementBounds.Bottom));
var isFullyVisible = containerRect.Contains(new Point(elementBounds.Left, elementBounds.Top)) && containerRect.Contains(new Point(elementBounds.Right, elementBounds.Bottom));
// Check if the rectangle is completely in the window.
// If it is not and intertia is occuring, stop the manipulation.
if (e.IsInertial && !isPartiallyVisible)
{
e.Complete();
}
}
private void BDswip_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
e.Handled = true;
// 仅当 SplitView 处于 Overlay 模式时（窗口宽度最小时）
if (SPVmenu.DisplayMode == SplitViewDisplayMode.Overlay)
{
if (PaneRoot == null)
{
// 找到 SplitView 控件中，模板的父容器
Grid grid = Util.FindVisualChild <Grid>(SPVmenu);
PaneRoot = grid.FindName("PaneRoot") as Grid;
if (from_ClosedToOpenOverlayLeft_Transition == null)
{
// 获取 SplitView 模板中“视觉状态集合”
IList <VisualStateGroup> stateGroup = VisualStateManager.GetVisualStateGroups(grid);
// 获取 VisualTransition 对象的集合。
IList <VisualTransition> transitions = stateGroup[0].Transitions;
// 找到 SplitView.IsPaneOpen 设置为 true 时，播放的 transition
from_ClosedToOpenOverlayLeft_Transition = transitions?.Where(train => train.From == "Closed" && train.To == "OpenOverlayLeft").First();
}
}
// 默认为 Collapsed，所以先显示它
PaneRoot.Visibility = Visibility.Visible;
// 当在 Border 上向右滑动，并且滑动的总距离需要小于 Panel 的默认宽度。否则会脱离左侧窗口，继续向右拖动
if (e.Cumulative.Translation.X >= 0 && e.Cumulative.Translation.X < SPVmenu.OpenPaneLength)
{
CompositeTransform ct = PaneRoot.RenderTransform as CompositeTransform;
ct.TranslateX = (e.Cumulative.Translation.X - SPVmenu.OpenPaneLength);
}
}
}
void ChildrenAddGrid_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
MovingWithAndHeight();
if (forceManipulationsToEnd)
{
e.Complete();
return;
}
//放大
ct.ScaleX = ct.ScaleY *= e.Delta.Scale;
//旋转
//e.Delta.Rotation 原来是弧度 需要(e.Delta.Rotation * 180 / Math.PI)
//ct.Rotation += (e.Delta.Rotation * 180 / Math.PI);
//现在是角度
ct.Rotation += e.Delta.Rotation;
//ct.CenterX = (this.ChildrenAddGrid as FrameworkElement).ActualWidth / 2;
//ct.CenterY = (this.ChildrenAddGrid as FrameworkElement).ActualHeight / 2;
//平移
ct.TranslateX += e.Delta.Translation.X;
ct.TranslateY += e.Delta.Translation.Y;
if (System.Math.Round(ct.ScaleX, 1) <= 0.25)
{
ct.ScaleX = 0.25;
ct.ScaleY = 0.25;
}
if (System.Math.Abs(ct.TranslateY) >= movingInterpolationH || System.Math.Abs(ct.TranslateX) >= movingInterpolationW)
{
if (MovingBeyondTheBorderComplete != null)
{
this.MovingBeyondTheBorderComplete();
}
}
e.Handled = true;
}
private void ellRightTop_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if ((rectRectangleForMovement.Width + e.Delta.Translation.X) >= MIN_RECTANGLE_MOVE_WIDTH &&
(rectRectangleForMovement.Height + (e.Delta.Translation.Y * -1)) >= MIN_RECTANGLE_MOVE_HEIGHT)
{
var moveX = createTranslateTransform(Math.Round(e.Delta.Translation.X), 0.0);
var moveY = createTranslateTransform(0.0, Math.Round(e.Delta.Translation.Y));
var moveXY = createTranslateTransform(moveX.X, moveY.Y);
var moveX2 = createTranslateTransform(moveX.X / 2.0, 0.0);
var moveY2 = createTranslateTransform(0.0, moveY.Y / 2.0);
var moveX2Y = createTranslateTransform(moveX2.X, moveY.Y);
var moveXY2 = createTranslateTransform(moveX.X, moveY2.Y);
setGridTransformsOfEllipses(moveX2, moveX2Y, moveXY2, moveY2,
null, moveY, moveX, moveXY);
changeMarginRightOfUiElements(moveX.X);
changeWidthOfUiElements(moveX.X);
changeHeightOfUiElements(moveY.Y * -1.0);
changeMarginTopOfUiElements(moveY.Y * -1.0);
setSizeOfRecBar(rectRectangleToDraw.Height, rectRectangleToDraw.Width);
}
}
private void Grid_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
e.Handled = true;
//progress.Visibility = Visibility.Visible;
double X = e.Delta.Translation.X;
if (X > 0)
{
double dd = X / this.ActualWidth;
double d = dd * 90;
ssValue += d;
//slider.Value += d;
Utils.ShowMessageToast("+" + ssValue.ToInt32() + "S", 2000);
}
else
{
double dd = Math.Abs(X) / this.ActualWidth;
double d = dd * 90;
ssValue -= d;
//slider.Value -= d;
Utils.ShowMessageToast("-" + ssValue.ToInt32() + "S", 2000);
}
}
private void theCanvas_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (isInInertion)
{
return;
}
var top = Canvas.GetTop(this.rect);
var left = Canvas.GetLeft(this.rect);
top += e.Delta.Translation.Y;
left += e.Delta.Translation.X;
var scale = e.Delta.Scale;
//var oldWidth = this.rect.Width;
//var oldHeight = this.rect.Height;
//this.rect.Width *= scale;
//this.rect.Height *= scale;
//top -= (this.rect.Height - oldHeight) / 2;
//left -= (this.rect.Width - oldWidth) / 2;
Canvas.SetTop(this.rect, top);
Canvas.SetLeft(this.rect, left);
var transform = this.rect.RenderTransform as CompositeTransform;
//transform.ScaleX += e.Delta.Scale / 100;
//transform.ScaleY += e.Delta.Scale / 100;
transform.CenterX = this.rect.Width / 2;
transform.CenterY = this.rect.Height / 2;
transform.Rotation += e.Delta.Rotation;
//transform.Angle += e.Delta.Rotation;
}
/// <summary>
/// Word opgeroepen tijdens het swypen.
/// er wordt gecontroleerd of de swype beëindigd is of niet (e.IsInertial). Indien wel, dan wordt het eindpunt bepaald
/// en wordt gekeken of de swype afstand op de X-as ver genoeg was om de menuanimatie te starten.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void PaginaGrid_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (e.IsInertial)
{
Point eindPunt = e.Position;
double afstand = eindPunt.X - beginPunt.X;
if (afstand >= 500)//500 is the threshold value, where you want to trigger the swipe right event
{
e.Complete();
if (!ucMenu.IsMenuOpen())
{
ucMenu.BeginMenuAnimatie();
}
}
else if (afstand <= -500)
{
e.Complete();
if (ucMenu.IsMenuOpen())
{
ucMenu.BeginMenuAnimatie();
}
}
}
}
void OnManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
var x = _panAreaTransform.TranslateX + e.Delta.Translation.X;
// keep the pan within the bountry
if (x < PanAreaInitialTranslateX || x > 0)
{
return;
}
// while we are panning the PanArea on X axis, let's sync the PaneRoot's position X too
_paneRootTransform.TranslateX = _panAreaTransform.TranslateX = x;
if (sender == _paneRoot && this.IsPanSelectorEnabled)
{
// un-highlight everything first
foreach (var item in _menuItems)
{
VisualStateManager.GoToState(item, "Normal", true);
}
_toBeSelectedIndex = (int)Math.Round((e.Cumulative.Translation.Y + _startingDistance) / _distancePerItem, MidpointRounding.AwayFromZero);
if (_toBeSelectedIndex < 0)
{
_toBeSelectedIndex = 0;
}
else if (_toBeSelectedIndex >= _menuItems.Count)
{
_toBeSelectedIndex = _menuItems.Count - 1;
}
// highlight the item that's going to be selected
var itemContainer = _menuItems[_toBeSelectedIndex];
VisualStateManager.GoToState(itemContainer, "PointerOver", true);
}
}
void HandlePinch(ManipulationDeltaRoutedEventArgs e, View view)
{
if (_fingers.Count < 2 || view == null)
{
return;
}
_isPinching = true;
Windows.Foundation.Point translationPoint = e.Container.TransformToVisual(Container).TransformPoint(e.Position);
var scaleOriginPoint = new Point(translationPoint.X / view.Width, translationPoint.Y / view.Height);
IEnumerable <PinchGestureRecognizer> pinchGestures = view.GestureRecognizers.GetGesturesFor <PinchGestureRecognizer>();
foreach (PinchGestureRecognizer recognizer in pinchGestures)
{
if (!_wasPinchGestureStartedSent)
{
recognizer.SendPinchStarted(view, scaleOriginPoint);
}
recognizer.SendPinch(view, e.Delta.Scale, scaleOriginPoint);
}
_wasPinchGestureStartedSent = true;
}
private void SwipeablePage_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
if (e.IsInertial && !_isSwiped)
{
var swipedDistance = e.Cumulative.Translation.X;
if (Math.Abs(swipedDistance) <= 2)
{
return;
}
if (swipedDistance > 0)
{
Debug.WriteLine("Swapping: Right Swapped");
Frame.Navigate(typeof(MainPage), null);
}
else
{
Debug.WriteLine("Swapping: Left Swapped");
//SwipeableTextBlock.Text = "Left Swiped";
}
_isSwiped = true;
}
}
/// <summary>
/// Called before the ManipulationDelta event occurs.
/// </summary>
/// <param name="e">Event data for the event.</param>
protected override void OnManipulationDelta(ManipulationDeltaRoutedEventArgs e)
{
base.OnManipulationDelta(e);
if (e.Handled)
{
return;
}
if (e.PointerDeviceType == PointerDeviceType.Touch)
{
e.Handled = this.ActualController.HandleTouchDelta(this, e.ToTouchEventArgs(this));
}
}
public virtual void OnManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
{
var el = e.OriginalSource as View;
int x = el.Left + e.Delta.Translation.X;
int y = el.Top + e.Delta.Translation.Y;
// left, top は同時に設定する必要あり
// RelativeLayoutHelper.SetLeft(el, x);
// RelativeLayoutHelper.SetTop(el, y);
RelativeLayoutHelper.SetXY(el, x, y);
}
