private void StackPanel_ManipulationDelta(object sender, ManipulationDeltaEventArgs e) { /* if (e.DeltaManipulation.Translation.Y != 0) return; if (Event != null) Event(this, e);*/ }
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; } }
void Button_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { e.Handled = true; bool isInBounds = true; Rect bounds = new Rect(new Point(0, 0), Button.RenderSize); foreach (IManipulator manipulator in e.Manipulators) { Point p = manipulator.GetPosition(Button); if (!bounds.Contains(p)) { isInBounds = false; break; } } if (!isInBounds) { e.Cancel(); } }
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 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(); }
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 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 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; } }
public override void Manipulate(System.Windows.Input.ManipulationDeltaEventArgs args, ref System.Windows.Media.Matrix matrix) { base.Manipulate(args, ref matrix); ManipulationDelta delta = args.DeltaManipulation; Point center = args.ManipulationOrigin; Vector scale = new Vector(matrix.M11, matrix.M22); if (MaxScale == 0.0 || MaxScale > scale.Length) { //matrix.ScaleAtPrepend(delta.Scale.X, delta.Scale.Y, center.X, center.Y); System.Windows.Media.Matrix m = new System.Windows.Media.Matrix(matrix.M11, matrix.M12, matrix.M21, matrix.M22, matrix.OffsetX, matrix.OffsetY); //m.ScalePrepend(delta.Scale.X, delta.Scale.Y); matrix.ScalePrepend(delta.Scale.X, delta.Scale.Y); if (!this.ElementInsideContainer() && (delta.Scale.X > 1 || delta.Scale.Y > 1)) { if (lastPositionInside != null) { matrix = m; //matrix = new System.Windows.Media.Matrix(lastPositionInside.M11, lastPositionInside.M12, lastPositionInside.M21, lastPositionInside.M22, lastPositionInside.OffsetX, lastPositionInside.OffsetY); } args.Handled = true; } else { lastPositionInside = new System.Windows.Media.Matrix(matrix.M11, matrix.M12, matrix.M21, matrix.M22, matrix.OffsetX, matrix.OffsetY); } } }
// 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; }
/// <summary> /// Step: 4 /// ManipulationDelta event occurs multiple times when the user drags a finger over the screen during manipulation. /// CumulativeManipulation property contains the total changes that occurred for the current manipulation. /// It further provides more details of the type of manipulation, e.g., translation, scaling, rotation, etc. /// The Velocities property give details on the current speed of manipulation and direction. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void centerImageView_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { //store values of horizontal & vertical cumulative translation cumulativeDeltaX = e.CumulativeManipulation.Translation.X; cumulativeDeltaY = e.CumulativeManipulation.Translation.Y; //store value of linear velocity into horizontal direction linearVelocity = e.Velocities.LinearVelocity.X; /// Added from part 2. Scale part. // get current matrix of the element. Matrix borderMatrix = ((MatrixTransform)centerImageView.RenderTransform).Matrix; //determine if action is zoom or pinch var maxScale = Math.Max(e.DeltaManipulation.Scale.X, e.DeltaManipulation.Scale.Y); //check if not crossing minimum and maximum zoom limit if ((maxScale < 1 && borderMatrix.M11 * maxScale > MinimumZoom) || (maxScale > 1 && borderMatrix.M11 * maxScale < MaximumZoom)) { //scale to most recent change (delta) in X & Y borderMatrix.ScaleAt(e.DeltaManipulation.Scale.X, e.DeltaManipulation.Scale.Y, centerImageView.ActualWidth / 2, centerImageView.ActualHeight / 2); //render new matrix centerImageView.RenderTransform = new MatrixTransform(borderMatrix); } }
private void canvas_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { if (e.DeltaManipulation.Translation.X != 0) { Canvas.SetLeft(LayoutRoot, Math.Min(Math.Max(-840, Canvas.GetLeft(LayoutRoot) + e.DeltaManipulation.Translation.X), 0)); } }
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 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 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; }
private void btnFull_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs args) { double dCX = args.ManipulationOrigin.X - m_ptDragStart.X; //Smaller movement... dCX = dCX / 5; imgFull.Margin = new Thickness(dCX, 0, -dCX, 0); }
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); }
void rect_ManipulationDelta(object sender, ManipulationDeltaEventArgs e) { Rectangle croppingRectangle = (Rectangle)sender; if (croppingRectangle.Width >= (int)e.DeltaManipulation.Translation.X) croppingRectangle.Width -= (int)e.DeltaManipulation.Translation.X; if (croppingRectangle.Height >= (int)e.DeltaManipulation.Translation.Y) croppingRectangle.Height -= (int)e.DeltaManipulation.Translation.Y; }
void MonitorManipulationDelta(object sender, ManipulationDeltaEventArgs e) { if (Movement != null) Movement(this, new MovementMonitorEventArgs { X = _xOffsetStartValue + e.CumulativeManipulation.Translation.X, Y = _yOffsetStartValue + e.CumulativeManipulation.Translation.Y }); e.Handled = true; }
protected override void OnManipulationDelta(ManipulationDeltaEventArgs e) { UIElement element = e.OriginalSource as UIElement; Point translation = e.DeltaManipulation.Translation; Canvas.SetLeft(element, Canvas.GetLeft(element) + translation.X); Canvas.SetTop(element, Canvas.GetTop(element) + translation.Y); jolidessin.Points.Add(new Point(Canvas.GetLeft(element) + translation.X, Canvas.GetTop(element) + translation.Y)); e.Handled = true; base.OnManipulationDelta(e); }
private void deleteButton_ManipulationDelta(object sender, ManipulationDeltaEventArgs e) { if (dmove.X > 260) { deleteButton.Background = transformingBrush; } // move it dmove.X += e.DeltaManipulation.Translation.X; }
private void Image_ManipulationDelta(object sender, ManipulationDeltaEventArgs e) { double previousRotation = transform.Rotation; transform.Rotation = 0.0; transform.TranslateX = e.CumulativeManipulation.Translation.X * transform.ScaleX + startingPositionOfImageX; transform.TranslateY = e.CumulativeManipulation.Translation.Y * transform.ScaleY + startingPositionOfImageY; transform.Rotation = previousRotation; }
/// <summary> /// Called when the <see cref="E:System.Windows.UIElement.ManipulationDelta" /> event occurs. /// </summary> /// <param name="e">The data for the event.</param> protected override void OnManipulationDelta(ManipulationDeltaEventArgs e) { base.OnManipulationDelta(e); if (e.Handled) { return; } e.Handled = this.Controller.HandleTouchDelta(this, e.ToTouchEventArgs(this)); }
private void ManipulationDelta(object sender, ManipulationDeltaEventArgs e) { // ignore delta event for Thumb // and derived. if (!_is_thumb) { // forward manipulation event _delta(e); } }
private void Canvas_ManipulationDelta(object sender, ManipulationDeltaEventArgs e) { var m = e.DeltaManipulation; var mx = tx.Matrix; mx.Translate(m.Translation.X, m.Translation.Y); mx.ScaleAt(m.Scale.X, m.Scale.X, e.ManipulationOrigin.X, e.ManipulationOrigin.Y); mx.RotateAt(m.Rotation, e.ManipulationOrigin.X, e.ManipulationOrigin.Y); tx.Matrix = mx; }
/// <summary> /// 页面设备更改期间时间 此处用于平移图片 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void MainPage_ManipulationDelta(object sender, ManipulationDeltaEventArgs e) { //if (e.DeltaManipulation.Scale.X > 0 && e.DeltaManipulation.Scale.Y > 0) //{ // this.imgScale.ScaleX *= e.DeltaManipulation.Scale.X; // this.imgScale.ScaleY *= e.DeltaManipulation.Scale.Y; //} this.imgTrans.X += e.DeltaManipulation.Translation.X; this.imgTrans.Y += e.DeltaManipulation.Translation.Y; }
void Manipulation(ManipulationDeltaEventArgs e) { var mt = new MatrixTransform(ShapeUtils.GetTransform(e)); var Point1 = mt.Transform(new Point(line.X1, line.Y1)); var Point2 = mt.Transform(new Point(line.X2, line.Y2)); line.X1 = Point1.X; line.Y1 = Point1.Y; line.X2 = Point2.X; line.Y2 = Point2.Y; }
protected override void OnManipulationDelta(ManipulationDeltaEventArgs e) { base.OnManipulationDelta(e); var element = e.OriginalSource as UIElement; var transformation = this.mainCanvas.RenderTransform as MatrixTransform; var matrix = transformation == null ? Matrix.Identity : transformation.Matrix; matrix.ScaleAt(e.DeltaManipulation.Scale.X, e.DeltaManipulation.Scale.Y, e.ManipulationOrigin.X, e.ManipulationOrigin.Y); matrix.RotateAt(e.DeltaManipulation.Rotation, e.ManipulationOrigin.X, e.ManipulationOrigin.Y); matrix.Translate(e.DeltaManipulation.Translation.X, e.DeltaManipulation.Translation.Y); this.mainCanvas.RenderTransform = new MatrixTransform(matrix); }
private void OnManipulationDelta(object sender, ManipulationDeltaEventArgs e) { if (DateTime.Now.Subtract(_LastOnManipulationDelta).TotalMilliseconds < 500) return; // throttle _LastOnManipulationDelta = DateTime.Now; InfoBox.Text = "Expansion: " + e.CumulativeManipulation.Expansion.ToString() + Environment.NewLine + "Rotation: " + e.CumulativeManipulation.Rotation.ToString() + Environment.NewLine + "Scale: " + e.CumulativeManipulation.Scale.ToString() + Environment.NewLine + "Translation: " + e.CumulativeManipulation.Translation.ToString() + Environment.NewLine + "Exp " + e.CumulativeManipulation.Expansion.X + "/" + e.CumulativeManipulation.Expansion.Y; } //
private void OnManipulationDelta(object sender, ManipulationDeltaEventArgs e) { if (!ReadOnly) { PerformValueCalculation(e.ManipulationOrigin, e.ManipulationContainer); UpdateDragHelper(); if (ShowSelectionHelper) { ChangeDragHelperVisibility(true); } } }
// UIElement.ManipulationDelta represents either a drag or a pinch. // If PinchManipulation == null, then we have a drag, corresponding to GestureListener.DragStarted, // GestureListener.DragDelta, or GestureListener.DragCompleted. // If PinchManipulation != null, then we have a pinch, corresponding to GestureListener.PinchStarted, // GestureListener.PinchDelta, or GestureListener.PinchCompleted. // // In this sample we track drag and pinch state to illustrate how to manage transitions between // pinching and dragging, but commonly only the pinch or drag deltas will be of interest, in which // case determining when pinches and drags begin and end is not necessary. // // Note that the exact APIs for the event args are not quite the same as the ones in GestureListener. // Comments inside methods called from here will note where they diverge. private void OnManipulationDelta(object sender, ManipulationDeltaEventArgs e) { bool oldIsPinch = isPinch; bool oldIsDrag = isDrag; isPinch = e.PinchManipulation != null; // The origin of the first manipulation after a pinch is completed always corresponds to the // primary touch point from the pinch, even if the secondary touch point is the one that // remains active. In this sample we only want a drag to affect the rectangle if the finger // on the screen falls inside the rectangle's bounds, so if we've just finished a pinch, // we have to defer until the next ManipulationDelta to determine whether or not a new // drag has started. isDrag = e.PinchManipulation == null && !oldIsPinch; // check for ending gestures if (oldIsDrag && !isDrag) { this.OnDragCompleted(); } if (oldIsPinch && !isPinch) { this.OnPinchCompleted(); } // check for continuing gestures if (oldIsDrag && isDrag) { this.OnDragDelta(sender, e); } if (oldIsPinch && isPinch) { this.OnPinchDelta(sender, e); } // check for starting gestures if (!oldIsDrag && isDrag) { // Once a manipulation has started on the UIElement, that element will continue to fire ManipulationDelta // events until all fingers have left the screen and we get a ManipulationCompleted. In this sample // however, we treat each transition between pinch and drag as a new gesture, and we only want to // apply effects to our border control if the the gesture begins within the bounds of the border. isGestureOnTarget = e.ManipulationContainer == border && new Rect(0, 0, border.ActualWidth, border.ActualHeight).Contains(e.ManipulationOrigin); this.OnDragStarted(); } if (!oldIsPinch && isPinch) { isGestureOnTarget = e.ManipulationContainer == border && new Rect(0, 0, border.ActualWidth, border.ActualHeight).Contains(e.PinchManipulation.Original.PrimaryContact); this.OnPinchStarted(sender, e); } }
void OnManipDelta(object sender, ManipulationDeltaEventArgs e) { var pt = e.ManipulationOrigin; if (pt.X < 0 || pt.X > this.Width || pt.Y < 0 || pt.Y > this.Height) _imgbrush.ImageSource = _normalimg; else _imgbrush.ImageSource = _focusimg; e.Handled = true; }
void RatingControl_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { if (IsEditable && AllowHover && IsEnabled && Visibility == Visibility.Visible && e != null && e.ManipulationOrigin != null) { e.Handled = true; if (DEBUG_MODE) { System.Diagnostics.Debug.WriteLine("ManipulationDelta {0} - {1}", DateTime.Now, e.ManipulationOrigin.X); } double x = e.ManipulationOrigin.X; ChangeItemsValue(x); } }
private void OnManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { var maxSize = _heights[ApplicationBarState.Full]; var minSize = (ApplicationBarMinimizedStateView == ApplicationBarMinimizedState.Minimized ? _heights[ApplicationBarState.Minimized] : 0); var desiredTransform = TranslateTransform.Y + e.DeltaManipulation.Translation.Y; var normalizedTransform = -Math.Max(minSize, Math.Min(maxSize, -desiredTransform)); TranslateTransform.Y = normalizedTransform; e.Handled = true; }
private void OnManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { if (e.ManipulationOrigin.Y >= 400) { x1Distance = e.CumulativeManipulation.Translation.X; y1Distance = e.CumulativeManipulation.Translation.Y; base.OnManipulationDelta(e); } if (e.ManipulationOrigin.Y < 400) { x2Distance = e.CumulativeManipulation.Translation.X; y2Distance = e.CumulativeManipulation.Translation.Y; base.OnManipulationDelta(e); } }
public override void Manipulate(System.Windows.Input.ManipulationDeltaEventArgs args, ref System.Windows.Media.Matrix matrix) { base.Manipulate(args, ref matrix); Vector trans; bool contain = true; if (DisableBounce) { matrix.Translate(args.DeltaManipulation.Translation.X, args.DeltaManipulation.Translation.Y); } else { contain = Contains(this.Manipulator.ContainerControl as FrameworkElement, args.DeltaManipulation, out trans); matrix.Translate(trans.X, trans.Y); } }
/// <summary> /// Tell the gestures to make the manipulation /// </summary> /// <param name="sender"></param> /// <param name="args"></param> void element_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs args) { if (this.Element == null) { args.Cancel(); return; } ApplyTransformForcedByGesture = null; Transform transform = Utility.GetMatrixTransformFromTransform(this.ElementTransform); //apply gestures if (transform is MatrixTransform) { Matrix matrix = (transform as MatrixTransform).Matrix; foreach (aGesture gest in Gestures) { if (gest.IsEnabled) { if (args.Handled) { break; } gest.Manipulate(args, ref matrix); // refresh matrix if gesture forced it. exept if it is the the last gesture of the list. if (ApplyTransformForcedByGesture == gest && Gestures.Last() != gest) { transform = Utility.GetMatrixTransformFromTransform(this.ElementTransform); matrix = (transform as MatrixTransform).Matrix; ApplyTransformForcedByGesture = null; } } } // do not apply it twice if (ApplyTransformForcedByGesture == null) { ApplyTransform(matrix); } } args.Handled = true; }
public override void Manipulate(System.Windows.Input.ManipulationDeltaEventArgs args, ref System.Windows.Media.Matrix matrix) { base.Manipulate(args, ref matrix); ManipulationDelta delta = args.DeltaManipulation; Point center = args.ManipulationOrigin; Debug.WriteLine("=============================="); Debug.WriteLine("0: " + center); System.Windows.Media.Matrix m = new System.Windows.Media.Matrix(matrix.M11, matrix.M12, matrix.M21, matrix.M22, matrix.OffsetX, matrix.OffsetY); matrix.RotatePrepend(delta.Rotation); if (!this.ElementInsideContainer()) { matrix = m; } }
public override void Manipulate(System.Windows.Input.ManipulationDeltaEventArgs args, ref System.Windows.Media.Matrix matrix) { //base.Manipulate(args, ref matrix); var manipulators = from tm in ManipulatorContainer.Instance.Manipulators where tm != this.Manipulator && tm.ContainerControl == this.Manipulator.ContainerControl && (from gest in tm.Gestures where gest.IsEnabled && gest is TranslateWithCollision && ((TranslateWithCollision)gest).CollisionGroup.Equals(this.CollisionGroup) select gest).Count() > 0 select tm; foreach (TouchManipulator tm in manipulators) { Vector trans; bool contain = true; contain = Collide(this.Manipulator.Element, tm.Element, args.DeltaManipulation.Translation, out trans); if (contain) { //manipulator2.Element. //Manipulation.SetManipulationParameter(tm.Element //Manipulation.StartInertia(tm.Element); //System.Windows.Input.ManipulationDeltaEventArgs a = new ManipulationDeltaEventArgs //MatrixAnimation animation = new MatrixAnimation(oldMatrix, newMatrix, new Duration(new TimeSpan(0, 0, 1))) //{ // EasingFunction = new PowerEase { EasingMode = EasingMode.EaseInOut, Power = 2 } //}; // Manipulation. } // if (contain) matrix.Translate(trans.X, trans.Y); } }
private void _internetAccessBrowser_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { if (!e.Handled) { var point = e.ManipulationOrigin; var browser = sender as ChromiumWebBrowser; if (browser != null) { browser.SendMouseWheelEvent( (int)point.X, (int)point.Y, deltaX: (int)e.DeltaManipulation.Translation.X, deltaY: (int)e.DeltaManipulation.Translation.Y, modifiers: CefEventFlags.None); } } }
private void viewport_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { if (e.PinchManipulation != null) { double newWidth, newHieght; if (m_Width < m_Height) // box new size between image size and viewport actual size { newHieght = m_Height * m_Zoom * e.PinchManipulation.CumulativeScale; newHieght = Math.Max(viewport.ActualHeight, newHieght); newHieght = Math.Min(newHieght, m_Height); newWidth = newHieght * m_Width / m_Height; } else { newWidth = m_Width * m_Zoom * e.PinchManipulation.CumulativeScale; newWidth = Math.Max(viewport.ActualWidth, newWidth); newWidth = Math.Min(newWidth, m_Width); newHieght = newWidth * m_Height / m_Width; } if (newWidth < m_Width && newHieght < m_Height) { // Tells image positione in viewport (offset) MatrixTransform transform = image.TransformToVisual(viewport) as MatrixTransform; // Calculate center of pinch gesture on image (not screen) Point pinchCenterOnImage = transform.Transform(e.PinchManipulation.Original.Center); // Calculate relative point (0-1) of pinch center in image Point relativeCenter = new Point(e.PinchManipulation.Original.Center.X / image.Width, e.PinchManipulation.Original.Center.Y / image.Height); // Calculate and set new origin point of viewport Point newOriginPoint = new Point(relativeCenter.X * newWidth - pinchCenterOnImage.X, relativeCenter.Y * newHieght - pinchCenterOnImage.Y); viewport.SetViewportOrigin(newOriginPoint); } image.Width = newWidth; image.Height = newHieght; // Set new view port bound viewport.Bounds = new Rect(0, 0, newWidth, newHieght); } }
protected virtual void OnBorderManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { // suppress zoom if (e.DeltaManipulation.Scale.X != 0.0 || e.DeltaManipulation.Scale.Y != 0.0) { e.Handled = true; } // optionally suppress scrolling if (ScrollDisabled) { if (e.DeltaManipulation.Translation.X != 0.0 || e.DeltaManipulation.Translation.Y != 0.0) { e.Handled = true; } } }
private void centerImageView_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { // get current matrix of the element. Matrix borderMatrix = ((System.Windows.Media.MatrixTransform)MapImage.RenderTransform).Matrix; //determine if action is zoom or pinch var maxScale = Math.Max(e.DeltaManipulation.Scale.X, e.DeltaManipulation.Scale.Y); //check if not crossing minimum and maximum zoom limit if ((maxScale < 1 && borderMatrix.M11 * maxScale > 0) || (maxScale > 1 && borderMatrix.M11 * maxScale < 100)) { //scale to most recent change (delta) in X & Y borderMatrix.ScaleAt(e.DeltaManipulation.Scale.X, e.DeltaManipulation.Scale.Y, MapImage.ActualWidth / 2, MapImage.ActualHeight / 2); //render new matrix MapImage.RenderTransform = new MatrixTransform(borderMatrix); } }
/// <summary> /// override this to make manipulation on the Matrix (rotate, translate, etc). /// Call "base.Manipulate(delta)" in any case the top of the method when override. it makes some filter and validation /// </summary> /// <param name="delta"></param> public virtual void Manipulate(System.Windows.Input.ManipulationDeltaEventArgs args, ref Matrix matrix) { if (!this.IsEnabled) { return; } if (Manipulator == null) { throw new Exception("Please set the Manipulator of the Gesture!"); } //find guestures witch has this gesture in there omit list and skip this gesture if founded if (ManipulatorContainer.Instance.Manipulators.FirstOrDefault(a => a.Gestures.FirstOrDefault(b => b.IsEnabled && b.OmitGestures.Contains(this.GetType())) != null) != null) { return; } }
public virtual void OnManipulationDelta(System.Windows.Input.ManipulationDeltaEventArgs manipulationEventArgs, int width, int height) { Console.WriteLine("Got manipulation delta."); }
private void slider_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { player.Position = TimeSpan.FromSeconds(slider.Value); }
private void wb_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { e.Handled = false; }
private void OnManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { xDistance = e.CumulativeManipulation.Translation.X; yDistance = e.CumulativeManipulation.Translation.Y; base.OnManipulationDelta(e); }
public void OnManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e) { Console.WriteLine("ViewerContext got manipulation delta event."); }
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; } } } }