C# Input.ManipulationDeltaEventArgs類代碼示例

        void OnManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            if (e.PinchManipulation != null)
            {
                e.Handled = true;

                if (!_pinching)
                {
                    _pinching = true;
                    Point center = e.PinchManipulation.Original.Center;
                    _relativeMidpoint = new Point(center.X / SystemMapImage.ActualWidth, center.Y / SystemMapImage.ActualHeight);

                    var xform = SystemMapImage.TransformToVisual(ImageViewPort);
                    _screenMidpoint = xform.Transform(center);
                }

                _scale = _originalScale * e.PinchManipulation.CumulativeScale;

                CoerceScale(false);
                ResizeImage(false);
            }
            else if (_pinching)
            {
                _pinching = false;
                _originalScale = _scale = _coercedScale;
            }
        }

        private void ImageGrid_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            if (e.PinchManipulation != null)
            {
                //縮放
                _bokehManger.ScaleChange(e.PinchManipulation.DeltaScale);

                _bokehManger.RotationChange(e.PinchManipulation.Current, e.PinchManipulation.Original);

                TouchPanel.EnabledGestures = GestureType.None;
            }
            else
            {
                while (TouchPanel.IsGestureAvailable)
                {
                    GestureSample sample = TouchPanel.ReadGesture();
                    Point sampleDelta = new Point(sample.Delta.X, sample.Delta.Y);
                    _bokehManger.PositionChange(sampleDelta);
                }
                if (!TouchPanel.IsGestureAvailable)
                {
                    _bokehManger.SetPreAngel();
                }
            }
            _bokehManger.SetGradient();
        }

 // Al arrastrar el circulo.
 private void negro_ManipulationDelta_1(object sender, ManipulationDeltaEventArgs e)
 {
     FrameworkElement elipse = sender as FrameworkElement;
     elipse.RenderTransform = dragTranslation;
     dragTranslation.TranslateX = dragTranslation.TranslateX + e.DeltaManipulation.Translation.X;
     dragTranslation.TranslateY = dragTranslation.TranslateY + e.DeltaManipulation.Translation.Y;
 }

 private void OnManipulationDelta(object Sender, ManipulationDeltaEventArgs DeltaRoutedEventArgs)
 {
     if (DeltaRoutedEventArgs.CumulativeManipulation.Translation.X < -30)
     {
         _gameGrid.HandleMove(MoveDirection.Left);
         DeltaRoutedEventArgs.Complete();
         DeltaRoutedEventArgs.Handled = true;
     }
     else if (DeltaRoutedEventArgs.CumulativeManipulation.Translation.X > 30)
     {
         _gameGrid.HandleMove(MoveDirection.Right);
         DeltaRoutedEventArgs.Complete();
         DeltaRoutedEventArgs.Handled = true;
     }
     else if (DeltaRoutedEventArgs.CumulativeManipulation.Translation.Y < -30)
     {
         _gameGrid.HandleMove(MoveDirection.Up);
         DeltaRoutedEventArgs.Complete();
         DeltaRoutedEventArgs.Handled = true;
     }
     else if (DeltaRoutedEventArgs.CumulativeManipulation.Translation.Y > 30)
     {
         _gameGrid.HandleMove(MoveDirection.Down);
         DeltaRoutedEventArgs.Complete();
         DeltaRoutedEventArgs.Handled = true;
     }
 }

        protected override void OnManipulationDelta(ManipulationDeltaEventArgs e)
        {
            Card element = e.Source as Card;
            ManipulationDelta delta = e.DeltaManipulation;
            Point center = e.ManipulationOrigin;
            Matrix matrix = new Matrix();
            if (STATICS.MIN_CARD_SCALE < element.CurrentScale * delta.Scale.X && element.CurrentScale * delta.Scale.X < STATICS.MAX_CARD_SCALE)
            {
                element.CurrentScale = element.CurrentScale * delta.Scale.X;
                matrix.Scale(element.CurrentScale, element.CurrentScale);
            }
            else
            {
                matrix.Scale(element.CurrentScale, element.CurrentScale);
            }
            element.CurrentPosition = new Point(element.CurrentPosition.X + delta.Translation.X, element.CurrentPosition.Y + delta.Translation.Y);
            element.CurrentRotation += delta.Rotation;

            matrix.Rotate(element.CurrentRotation);
            matrix.Translate(element.CurrentPosition.X, element.CurrentPosition.Y);

            element.RenderTransform = new MatrixTransform(matrix);

            mainWindow.LinkingGestureLayer.Move(element);
            e.Handled = true;
            base.OnManipulationDelta(e);
        }

 private void Border_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
 {
     // suppress zoom
     if (e.DeltaManipulation.Scale.X != 0.0 ||
         e.DeltaManipulation.Scale.Y != 0.0)
         e.Handled = true;
 }

        private void cropArea_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            /**
             *  all of this code keeps the picture within the boundaries
             */

            drag.Y += e.DeltaManipulation.Translation.Y;
            if (drag.Y < 0)
                drag.Y = 0;
            if (drag.Y > max)
                drag.Y = max;

            int temp = current + (int)e.DeltaManipulation.Translation.Y;
            if (temp < min)
            {
                lowerBound.Height = originalPhoto.Height - cropArea.Height;
                upperBound.Height = 0;
                current = min;
            }
            else if (temp > max)
            {
                upperBound.Height = originalPhoto.Height - cropArea.Height;
                lowerBound.Height = 0;
                current = max;
            }
            else
            {
                upperBound.Height = temp;
                lowerBound.Height = max - temp;
                current = temp;
            }
        }

        private void Element_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            if (!IsEnabled)
            return;

              if (!IsActive)
              {
            // has the user dragged far enough?
            if (Math.Abs(e.CumulativeManipulation.Translation.X) < DragStartedDistance)
              return;

            IsActive = true;

            // initialize the drag
            FrameworkElement fe = sender as FrameworkElement;
            fe.SetHorizontalOffset(0);

            // find the container for the tick and cross graphics
            _tickAndCrossContainer = fe.Descendants()
                                   .OfType<FrameworkElement>()
                                   .Single(i => i.Name == "tickAndCross");
              }
              else
              {
            // handle the drag to offset the element
            FrameworkElement fe = sender as FrameworkElement;
            double offset = fe.GetHorizontalOffset().Value + e.DeltaManipulation.Translation.X;
            fe.SetHorizontalOffset(offset);

            _tickAndCrossContainer.Opacity = TickAndCrossOpacity(offset);
              }
        }

        private void cropArea_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            drag.X += e.DeltaManipulation.Translation.X;
            if (drag.X < 0)
                drag.X = 0;
            if (drag.X > max)
                drag.X = max;

            int temp = current + (int)e.DeltaManipulation.Translation.X;
            if (temp < min)
            {
                rightBound.Width = originalPhoto.Width - cropArea.Width;
                leftBound.Width = 0;
                current = min;
            }
            else if (temp > max)
            {
                leftBound.Width = originalPhoto.Width - cropArea.Width;
                rightBound.Width = 0;
                current = max;
            }
            else
            {
                leftBound.Width = temp;
                rightBound.Width = max - temp;
                current = temp;
            }
        }

        private void image_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            // Get the image that's being manipulated.            
            FrameworkElement element = (FrameworkElement)e.Source;

            // Use the matrix to manipulate the element.
            Matrix matrix = ((MatrixTransform)element.RenderTransform).Matrix;

            var deltaManipulation = e.DeltaManipulation;
            // Find the old center, and apply the old manipulations.
            Point center = new Point(element.ActualWidth / 2, element.ActualHeight / 2);
            center = matrix.Transform(center);

            // Apply zoom manipulations.
            matrix.ScaleAt(deltaManipulation.Scale.X, deltaManipulation.Scale.Y, center.X, center.Y);

            // Apply rotation manipulations.
            matrix.RotateAt(e.DeltaManipulation.Rotation, center.X, center.Y);

            // Apply panning.
            matrix.Translate(e.DeltaManipulation.Translation.X, e.DeltaManipulation.Translation.Y);

            // Set the final matrix.
            ((MatrixTransform)element.RenderTransform).Matrix = matrix;

        }

 private void StackPanel_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
 {
     /* if (e.DeltaManipulation.Translation.Y != 0)
          return;
      if (Event != null)
          Event(this, e);*/
 }

        private void Border_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            if (Math.Abs(e.DeltaManipulation.Translation.X) > Math.Abs(e.DeltaManipulation.Translation.Y))
                e.Handled = true;

            if (e.CumulativeManipulation.Scale.X != 0.0 || e.CumulativeManipulation.Scale.Y != 0.0)
                e.Handled = true;
        }

        protected override void OnManipulationDelta(ManipulationDeltaEventArgs e)
        {
            base.OnManipulationDelta(e);

            TransformMap(e.ManipulationOrigin,
                (Point)e.DeltaManipulation.Translation, e.DeltaManipulation.Rotation,
                (e.DeltaManipulation.Scale.X + e.DeltaManipulation.Scale.Y) / 2d);
        }

        public void ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            Manipulation(e);

            updateUserCursor();

            SetMarkers();
            e.Handled = true;
        }

        protected override void OnManipulationDelta(ManipulationDeltaEventArgs args)
        {
            if (!manipulationDeltaInProgress)
            {
                IsActive = true;

                if (!tapInertiaInProgess)
                    SelectedIndex = -1;
            }

            manipulationDeltaInProgress = true;

            // This is the fake inertia from a tap
            if (tapInertiaInProgess)
            {
                VerticalOffset -= args.DeltaManipulation.Translation.Y;
            }

            // All other direct manipulation and inertia
            else
            {
                // For non-wrappable panel, check for end of the line
                if (!isWrappableStackPanel)
                {
                    double newVerticalOffset = VerticalOffset - inertiaDirection * args.DeltaManipulation.Translation.Y;

                    if (FractionalCenteredIndexFromVerticalOffset(newVerticalOffset, false) < 0)
                    {
                        double verticalOffsetIncrement = VerticalOffset - VerticalOffsetFromCenteredIndex(0);
                        double verticalOffsetExcess = args.DeltaManipulation.Translation.Y - verticalOffsetIncrement;
                        VerticalOffset -= verticalOffsetIncrement;
                        SelectedIndex = 0;
                        args.ReportBoundaryFeedback(new ManipulationDelta(new Vector(0, verticalOffsetExcess), 0, new Vector(), new Vector()));
                        args.Complete();
                    }
                    else if (FractionalCenteredIndexFromVerticalOffset(newVerticalOffset, false) > Items.Count - 1)
                    {
                        double verticalOffsetIncrement = VerticalOffsetFromCenteredIndex(Items.Count - 1) - VerticalOffset;
                        double verticalOffsetExcess = args.DeltaManipulation.Translation.Y - verticalOffsetIncrement;
                        VerticalOffset += verticalOffsetIncrement;
                        SelectedIndex = Items.Count - 1;
                        args.ReportBoundaryFeedback(new ManipulationDelta(new Vector(0, verticalOffsetExcess), 0, new Vector(), new Vector()));
                        args.Complete();
                    }
                }

                // Here's where scrolling might reverse itself
                if (args.IsInertial && inertiaToUnknownIndex && !reverseInertiaChecked)
                    CheckForBackupManeuver(VerticalOffset, args.DeltaManipulation.Translation.Y, args.Velocities.LinearVelocity.Y);

                // This is the normal direct manipulation and inertia
                VerticalOffset -= inertiaDirection * args.DeltaManipulation.Translation.Y;
            }

            base.OnManipulationDelta(args);
        }