Inheritance: MonoBehaviour
Ejemplo n.º 1
0
        public override bool ContinueTracking(UITouch uitouch, UIEvent uievent)
        {
            if (!minThumbOn && !maxThumbOn)
                return true;

            var touchPoint = uitouch.LocationInView (this);
            if (minThumbOn)
            {
                minThumb.Center = new PointF(Math.Max (
                    XForValue(MinValue), Math.Min(touchPoint.X - distanceFromCenter, XForValue(SelectedMaxValue - MinRange))), minThumb.Center.Y - Frame.Top);
                SelectedMinValue = ValueForX (minThumb.Center.X);
            }

            if (maxThumbOn)
            {

                maxThumb.Center = new PointF(Math.Min (
                    XForValue(MaxValue),
                    Math.Max(
                        touchPoint.X - distanceFromCenter,
                        XForValue(SelectedMinValue + MinRange)
                      )
                    ), maxThumb.Center.Y - Frame.Top);

                SelectedMaxValue = ValueForX (maxThumb.Center.X);
            }

            UpdateTrackHighlight();
            this.SetNeedsLayout();

            if (ThumbChanged != null) ThumbChanged(this);

            return true;
        }
Ejemplo n.º 2
0
		protected void AddSpot (UITouch touch)
		{
			// create a random color spot at the point of touch, then add it to the others
			Spot spot = Spot.CreateNewRandomColor (touch.LocationInView (this));
			touchSpots.Add (spot);
			// tell the OS to redraw
			SetNeedsDisplay ();
		}
        public override void EndTracking(UITouch uitouch, UIEvent uievent)
        {
            _leftKnobLayer.Highlighted = false;
            _rightKnobLayer.Highlighted = false;

            _leftKnobLayer.SetNeedsDisplay ();
            _rightKnobLayer.SetNeedsDisplay ();
        }
Ejemplo n.º 4
0
		public override bool ContinueTracking (UITouch uitouch, UIEvent uievent)
		{
			var touch = uievent.AllTouches.AnyObject as UITouch;
			if (Bounds.Contains (touch.LocationInView (this)))
				isPressed = true;
			else
				isPressed = false;
			return base.ContinueTracking (uitouch, uievent);
		}
Ejemplo n.º 5
0
        public override bool BeginTracking(UITouch uitouch, UIEvent uievent)
        {
            if (uievent.Type == UIEventType.Touches)
            {
                SetNeedsDisplay();
            }

            return base.BeginTracking(uitouch, uievent);
        }
Ejemplo n.º 6
0
		public override void EndTracking (UITouch uitouch, UIEvent uievent)
		{
			if (isPressed && Enabled){
				if (Tapped != null)
					Tapped (this);
			}
			isPressed = false;
			SetNeedsDisplay ();
			base.EndTracking (uitouch, uievent);
		}
Ejemplo n.º 7
0
 public override void EndTracking(UITouch uitouch, UIEvent uievent)
 {
     if (pressed && Enabled)
     {
         Tapped?.Invoke(this);
     }
     pressed = false;
     SetNeedsDisplay();
     base.EndTracking(uitouch, uievent);
 }
Ejemplo n.º 8
0
		public bool UpdateWithTouch (UITouch touch)
		{
			NSNumber estimationUpdateIndex = touch.EstimationUpdateIndex;

			if (estimationUpdateIndex != EstimationUpdateIndex)
				return false;

			// An array of the touch properties that may be of interest.
			UITouchProperties[] touchProperties = {
				UITouchProperties.Location,
				UITouchProperties.Force,
				UITouchProperties.Altitude,
				UITouchProperties.Azimuth
			};

			// Iterate through possible properties.
			foreach (var expectedProperty in touchProperties) {
				// If an update to this property is not expected, continue to the next property.
				if (EstimatedPropertiesExpectingUpdates.Has (expectedProperty))
					continue;

				switch (expectedProperty) {
				case UITouchProperties.Force:
					Force = touch.Force;
					break;
				case UITouchProperties.Azimuth:
					AzimuthAngle = touch.GetAzimuthAngle (touch.View);
					break;
				case UITouchProperties.Altitude:
					AltitudeAngle = touch.AltitudeAngle;
					break;
				case UITouchProperties.Location:
					Location = touch.LocationInView (touch.View);
					PreciseLocation = touch.PreviousLocationInView (touch.View);
					break;
				}

				if (!touch.EstimatedProperties.Has (expectedProperty)) {
					// Flag that this point now has a 'final' value for this property.
					EstimatedProperties = EstimatedProperties.Remove (expectedProperty);
				}

				if (!touch.EstimatedPropertiesExpectingUpdates.Has (expectedProperty)) {
					// Flag that this point is no longer expecting updates for this property.
					EstimatedPropertiesExpectingUpdates = EstimatedPropertiesExpectingUpdates.Remove (expectedProperty);

					if (EstimatedPropertiesExpectingUpdates == 0) {
						PointType = this.PointType.Remove (PointType.NeedsUpdate);
						PointType = this.PointType.Add (PointType.Updated);
					}
				}
			}

			return true;
		}
Ejemplo n.º 9
0
        public CGRect AddPointOfType(PointType pointType, UITouch touch)
        {
            var previousPoint = Points.LastOrDefault ();
            var previousSequenceNumber = previousPoint != null ? previousPoint.SequenceNumber : -1;
            var point = new LinePoint (touch, previousSequenceNumber + 1, pointType);

            if (point.EstimationUpdateIndex != null && point.EstimatedPropertiesExpectingUpdates != 0)
                pointsWaitingForUpdatesByEstimationIndex [point.EstimationUpdateIndex] = point;

            Points.Add (point);
            return UpdateRectForLinePoint (point, previousPoint);
        }
Ejemplo n.º 10
0
        public override bool BeginTracking(UITouch uitouch, UIEvent uievent)
        {
            var touchPoint = uitouch.LocationInView (this);

            if (minThumb.Frame.Contains (touchPoint)) {
                minThumbOn = true;
                distanceFromCenter = touchPoint.X - minThumb.Center.X;
            } else if (maxThumb.Frame.Contains (touchPoint)) {
                maxThumbOn = true;
                distanceFromCenter = touchPoint.X - maxThumb.Center.X;
            }

            return true;
        }
Ejemplo n.º 11
0
        private PointerState GetState(UITouch touch)
        {
            switch (touch.Phase)
            {
                case UITouchPhase.Began:
                    return PointerState.Down;
                case UITouchPhase.Moved:
                case UITouchPhase.Stationary:
                    return PointerState.Move;
                case UITouchPhase.Ended:
                    return PointerState.Up;
                case UITouchPhase.Cancelled:
                    return PointerState.Cancel;
            }

            throw new ArgumentException("Got an invalid Touch event in GetState");
        }
        public override bool BeginTracking(UITouch uitouch, UIEvent uievent)
        {
            var TouchPoint = uitouch.LocationInView (this);

            if (_leftKnobLayer.Frame.Contains (TouchPoint)) {
                _leftTouchPoint = TouchPoint;
                _leftKnobLayer.Highlighted = true;
                _leftKnobLayer.SetNeedsDisplay ();
            }
            else if (_rightKnobLayer.Frame.Contains (TouchPoint)) {
                _rightTouchPoint = TouchPoint;
                _rightKnobLayer.Highlighted = true;
                _rightKnobLayer.SetNeedsDisplay ();
            }

            return _leftKnobLayer.Highlighted || _rightKnobLayer.Highlighted;
        }
        public void TouchBegan(UITouch touch, UIView view)
        {
            var touchImgView = touchImageViewQueue.PopTouchImageView();

            touchImgView.Center = touch.LocationInView(view);
            view.AddSubview(touchImgView);

            touchImgView.Alpha     = 0.0f;
            touchImgView.Transform = CGAffineTransform.MakeScale(1.13f, 1.13f);
            SetTouchImageView(touchImgView, touch);

            UIView.Animate(duration: 0.1, animation: () =>
            {
                touchImgView.Alpha     = 1.0f;
                touchImgView.Transform = CGAffineTransform.MakeScale(1, 1);
            });

            touchesStartDateMapTable[touch] = DateTime.Now;
        }
Ejemplo n.º 14
0
        public override void TouchesBegan(NSSet touches, UIEvent evt)
        {
            base.TouchesBegan(touches, evt);

            UITouch touch      = (UITouch)touches.AnyObject;
            CGPoint touchPoint = touch.LocationInView(chart.PlotView);
            TKChartSelectionInfo hitTestInfo = chart.HitTestForPoint(touchPoint);

            if (hitTestInfo != null)
            {
                selectedPoint    = chart.VisualPointForSeries(hitTestInfo.Series, hitTestInfo.DataPointIndex);
                originalLocation = touchPoint;
                if (selectedPoint != null)
                {
                    selectedPoint.Animator = null;
                    originalPosition       = selectedPoint.Center;
                }
            }
        }
Ejemplo n.º 15
0
        public override void TouchesMoved(NSSet touches, UIEvent evt)
        {
            isCleared = false;
            UITouch touch = touches.AnyObject as UITouch;
            CGPoint point = touch.LocationInView(this);

            center++;
            points[center] = point;
            if (center == 4)
            {
                points[3] = new CGPoint((points[2].X + points[4].X) / 2f, (points[2].Y + points[4].Y) / 2f);
                path.MoveTo(points[0]);
                path.AddCurveToPoint(points[3], points[1], points[2]);
                SetNeedsDisplay();
                points[0] = points[3];
                points[1] = points[4];
                center    = 1;
            }
        }
Ejemplo n.º 16
0
        public override void TouchesMoved(MonoTouch.Foundation.NSSet touches, UIEvent evt)
        {
            // Create a path under the finger following the grid
            if (touches.Count == 1)
            {
                // Valid movement
                if (mParent.IsCreatingPath)
                {
                    UITouch touch = (UITouch)touches.AnyObject;

                    PointF fingerLocation = touch.LocationInView(this);

                    Cell cell = getCellFromViewCoordinates(fingerLocation);

                    mParent.CreatePath(cell);
                }
            }
            base.TouchesMoved(touches, evt);
        }
Ejemplo n.º 17
0
        private void FireEvent(
            TouchRecognizer recognizer,
            long id,
            TouchActionType actionType,
            UITouch touch,
            bool isInContact)
        {
            // Convert touch location to Xamarin.Forms Point value
            CGPoint cgPoint = touch.LocationInView(recognizer.View);
            Point   xfPoint = new Point(cgPoint.X, cgPoint.Y);

            // Get the method to call for firing events
            Action <Element, TouchActionEventArgs> onTouchAction = recognizer.touchEffect.OnTouchAction;

            // Call that method
            onTouchAction(
                recognizer.element,
                new TouchActionEventArgs(id, actionType, xfPoint, isInContact));
        }
Ejemplo n.º 18
0
        public override void TouchesEnded(NSSet touches, UIEvent evt)
        {
            base.TouchesEnded(touches, evt);
            UITouch touch = touches.AnyObject as UITouch;

            var cgPoint = touch.LocationInView(this);
            var point   = new SKPoint((float)this.ContentScaleFactor * (float)cgPoint.X, (float)this.ContentScaleFactor * (float)cgPoint.Y);
            var rect    = new SKRect(point.X - 25f, point.Y - 25f, point.X + 50f, point.Y + 50f);

            // if touch ended within current viewbox!
            if (takeButton.TouchUpInside(rect))
            {
                TakeButtonTouched?.Invoke(this, new EventArgs());
                Counter++;
            }

            if (flashButton.TouchUpInside(rect))
            {
                FlashButtonTouched?.Invoke(this, new EventArgs());
            }

            if (cameraButton.TouchUpInside(rect))
            {
                CameraButtonTouched?.Invoke(this, new EventArgs());
            }

            if (closeButton.TouchUpInside(rect))
            {
                CloseButtonTouched?.Invoke(this, new EventArgs());
            }

            if (sendButton.TouchUpInside(rect))
            {
                SendButtonTouched?.Invoke(this, new EventArgs());
            }

            if (counterButton.TouchUpInside(rect))
            {
                CounterButtonTouched?.Invoke(this, new EventArgs());
            }

            buttons.ForEach((btn) => btn.Touched = false);
        }
Ejemplo n.º 19
0
        public override bool BeginTracking(UITouch uitouch, UIEvent uievent)
        {
            var TouchPoint = uitouch.LocationInView(this);

            if (_leftKnobLayer.Frame.Contains(TouchPoint))
            {
                _leftTouchPoint            = TouchPoint;
                _leftKnobLayer.Highlighted = true;
                _leftKnobLayer.SetNeedsDisplay();
            }
            else if (_rightKnobLayer.Frame.Contains(TouchPoint))
            {
                _rightTouchPoint            = TouchPoint;
                _rightKnobLayer.Highlighted = true;
                _rightKnobLayer.SetNeedsDisplay();
            }

            return(_leftKnobLayer.Highlighted || _rightKnobLayer.Highlighted);
        }
Ejemplo n.º 20
0
        public override void TouchesMoved(NSSet touches, UIEvent evt)
        {
            UITouch touch = (UITouch)touches.AnyObject;

            UIView.PerformWithoutAnimation(() => {
                X = X + touch.LocationInView(Screen.GlobalScreen).X - touch.PreviousLocationInView(Screen.GlobalScreen).X;
                Y = Y + touch.LocationInView(Screen.GlobalScreen).Y - touch.PreviousLocationInView(Screen.GlobalScreen).Y;
                Clamp();
            });

            CGPoint newVelocity = CGPoint.Empty;

            newVelocity.X = touch.LocationInView(Screen.GlobalScreen).X - (nfloat)(touch.PreviousLocationInView(Screen.GlobalScreen).X / (touch.Timestamp - lastTime));
            newVelocity.Y = touch.LocationInView(Screen.GlobalScreen).Y - (nfloat)(touch.PreviousLocationInView(Screen.GlobalScreen).Y / (touch.Timestamp - lastTime));
            velocity.X    = 0.25f * velocity.X + 0.75f * newVelocity.X;
            velocity.Y    = 0.25f * velocity.Y + 0.75f * newVelocity.Y;

            lastTime = touch.Timestamp;
        }
Ejemplo n.º 21
0
        public override void TouchesEnded(NSSet touches, UIEvent evt)
        {
            base.TouchesEnded(touches, evt);

            ActivePanel.TouchesEnded( );

            UITouch touch = (UITouch)touches.AnyObject;

            CGPoint posInMain = touch.LocationInView(MainPanel);

            // if they tap outside the window (in the shaded area) dismiss this.
            if ((posInMain.X < 0 || posInMain.X > MainPanel.Bounds.Width) ||
                (posInMain.Y < 0 || posInMain.Y > MainPanel.Bounds.Height))
            {
                // confirm they want to cancel
                //ConfirmCancel( );
                DismissAnimated(false, null);
            }
        }
        public override bool ContinueTracking(UITouch uitouch, UIEvent uievent)
        {
            var TouchPoint = uitouch.LocationInView (this);

            if (_leftKnobLayer.Highlighted) {
                _leftTouchPoint = TouchPoint;
            } else if (_rightKnobLayer.Highlighted) {
                _rightTouchPoint = TouchPoint;
            }

            CATransaction.Begin ();
            CATransaction.DisableActions = true;

            SetLayerFrames ();

            CATransaction.Commit ();

            return _leftKnobLayer.Highlighted || _rightKnobLayer.Highlighted;
        }
Ejemplo n.º 23
0
        public override void TouchesBegan(NSSet touches, UIEvent evt)
        {
            base.TouchesBegan(touches, evt);

            // we can get the number of fingers from the touch count, but Multitouch must be enabled
            lblNumberOfFingers.Text = "Number of fingers: " + touches.Count.ToString();

            // get the touch
            UITouch touch = touches.AnyObject as UITouch;

            if (touch != null)
            {
                Console.WriteLine("screen touched");

                //==== IMAGE TOUCH
                if (imgTouchMe.Frame.Contains(touch.LocationInView(View)))
                {
                    lblTouchStatus.Text = "TouchesBegan";
                }

                //==== IMAGE DOUBLE TAP
                if (touch.TapCount == 2 && imgTapMe.Frame.Contains(touch.LocationInView(View)))
                {
                    if (imageHighlighted)
                    {
                        imgTapMe.Image = UIImage.FromBundle("Images/DoubleTapMe.png");
                    }
                    else
                    {
                        imgTapMe.Image = UIImage.FromBundle("Images/DoubleTapMe_Highlighted.png");
                    }
                    imageHighlighted = !imageHighlighted;
                }

                //==== IMAGE DRAG
                // check to see if the touch started in the dragme image
                if (imgDragMe.Frame.Contains(touch.LocationInView(View)))
                {
                    touchStartedInside = true;
                }
            }
        }
        void CheckForBoundaryHop(UITouch touch)
        {
            long id = touch.Handle.ToInt64();

            // TODO: Might require converting to a List for multiple hits
            TouchRecognizer recognizerHit = null;

            foreach (UIView view in viewDictionary.Keys)
            {
                CGPoint location = touch.LocationInView(view);

                if (new CGRect(new CGPoint(), view.Frame.Size).Contains(location))
                {
                    recognizerHit = viewDictionary[view];
                }
            }

            if (idToTouchDictionary.ContainsKey(id))
            {
                if (recognizerHit != idToTouchDictionary[id])
                {
                    if (idToTouchDictionary[id] != null)
                    {
                        FireEvent(idToTouchDictionary[id], id, TouchActionType.Exited, touch, true);
                    }

                    if (recognizerHit != null)
                    {
                        FireEvent(recognizerHit, id, TouchActionType.Entered, touch, true);
                    }
                    idToTouchDictionary[id] = recognizerHit;
                }
            }
            else
            {
                if (recognizerHit != null)
                {
                    FireEvent(recognizerHit, id, TouchActionType.Entered, touch, true);
                }
                idToTouchDictionary[id] = recognizerHit;
            }
        }
Ejemplo n.º 25
0
        public override void TouchesMoved(NSSet touches, UIEvent evt)
        {
            base.TouchesMoved(touches, evt);
            UITouch touch = touches.AnyObject as UITouch;

            currentPoint = touch.LocationInView(touch.View);

            if (newPoint || isEndPoint)
            {
                if (isSnapToGrid)
                {
                    bool stillInRange = CheckDragProximity();
                    if (!stillInRange)
                    {
                        UpdatePoint();
                    }
                }
                else
                {
                    UpdatePoint();
                };
            }
            else
            {
                if (touchMonitoring)
                {
                    bool stillInRange = CheckDragProximity();
                    if (stillInRange)
                    {
                        if (stopwatch.ElapsedMilliseconds > longPressTime)
                        {
                            touchMonitoring = false;
                            RemovePoint();
                        }
                    }
                    else
                    {
                        UpdatePoint();
                    }
                }
            }
        }
Ejemplo n.º 26
0
        public override void EndTracking(UITouch uitouch, UIEvent uievent)
        {
            base.EndTracking(uitouch, uievent);
            var touchLocationInView = uitouch?.LocationInView(this);

            if (touchLocationInView == null)
            {
                return;
            }

            //let offset = type(of: self).validBoundsOffset
            //let validBounds = CGRect(x: bounds.origin.x - offset, y: bounds.origin.y - offset, width: bounds.width + (2 * offset), height: bounds.height + (2 * offset))
            var validBounds = Bounds;

            if (validBounds.Contains(touchLocationInView.Value))
            {
                Checked = !Checked;
                SendActionForControlEvents(UIControlEvent.ValueChanged);
            }
        }
Ejemplo n.º 27
0
        public override void TouchesBegan(NSSet touches, UIEvent evt)
        {
            base.TouchesBegan(touches, evt);

            UITouch touch = touches.AnyObject as UITouch;

            if (touch != null)
            {
                PointF pt = touch.LocationInView(this);

                if (_path.ContainsPoint(pt, true))
                {
                    Title = "You touched the square";
                }
                else
                {
                    Title = "You didn't touch the square";
                }
            }
        }
Ejemplo n.º 28
0
        public override void TouchesBegan(NSSet touches, UIEvent evt)
        {
            UITouch aTouch   = (UITouch)touches.AnyObject;
            PointF  location = aTouch.LocationInView(this);

            var coordinate = _mapView.ConvertPoint(location, this);

            if (this.HasPoint)
            {
                _mapView.RemoveAnnotation(point);
                point = new PointAnnotation(coordinate, "Meeting Place", "Here");
                _mapView.AddAnnotation(point);
            }
            else
            {
                point = new PointAnnotation(coordinate, "Meeting Place", "Here");
                _mapView.AddAnnotation(point);
                this.HasPoint = true;
            }
        }
Ejemplo n.º 29
0
        public override void TouchesMoved(NSSet touches, UIEvent evt)
        {
            base.TouchesMoved(touches, evt);

            if (Mode == CropMode.Editing)
            {
                // adjust by the amount moved
                UITouch touch = touches.AnyObject as UITouch;
                if (touch != null)
                {
                    CGPoint touchPoint = touch.LocationInView(View);

                    CGPoint delta = new CGPoint(touchPoint.X - LastTapPos.X, touchPoint.Y - LastTapPos.Y);

                    MoveCropView(delta);

                    LastTapPos = touchPoint;
                }
            }
        }
Ejemplo n.º 30
0
        private PointerState GetState(UITouch touch)
        {
            switch (touch.Phase)
            {
            case UITouchPhase.Began:
                return(PointerState.Down);

            case UITouchPhase.Moved:
            case UITouchPhase.Stationary:
                return(PointerState.Move);

            case UITouchPhase.Ended:
                return(PointerState.Up);

            case UITouchPhase.Cancelled:
                return(PointerState.Cancel);
            }

            throw new ArgumentException("Got an invalid Touch event in GetState");
        }
Ejemplo n.º 31
0
        public override void TouchesMoved(NSSet touches, UIEvent evt)
        {
            base.TouchesMoved(touches, evt);
            UITouch touch = touches.AnyObject as UITouch;

            /* MyImageインスタンスの現在の座標 */
            var newPoint = touch.LocationInView(this);

            /* MyImageインスタンスの前回の座標 */
            var previousPoint = touch.PreviousLocationInView(this);

            /* 差分を計算 */
            nfloat dx = newPoint.X - previousPoint.X;
            nfloat dy = newPoint.Y - previousPoint.Y;

            /* コールバック */
            var el = this.Element as MyImage;

            el.Drug(el, new DrugEventArgs(el, dx, dy));
        }
Ejemplo n.º 32
0
        public override void TouchesBegan(NSSet touches, UIEvent touchEvent)
        {
            foreach (UITouch touch in touches)
            {
                if (TouchIsInRect(touch, padRect))
                {
                    padTouch = padTouch ?? touch;
                }
                else if (panningTouch == null)
                {
                    panningTouch = (UITouch)touches.AnyObject;
                }

                if (padTouch != null && panningTouch != null)
                {
                    break;
                }
            }
            base.TouchesBegan(touches, touchEvent);
        }
Ejemplo n.º 33
0
        public override void TouchesMoved(NSSet touches, UIEvent theEvent)
        {
            //            base.TouchesMoved(touches, evt);
            UITouch touch           = (UITouch)touches.AnyObject;
            CGPoint gestureEndPoint = touch.LocationInView(this);

            this.GestureDirection = this.GetGestureDirectionWithTouch(touch);
            bool canScroll = this.CanScroll(this.GestureDirection);

            if (canScroll)
            {
                if (this.TheDelegate != null)
                {
                    this.TheDelegate.iOSCardsView_Scrolling(this.GestureDirection);
                }
            }

            if ((this.GestureDirection == UISwipeGestureRecognizerDirection.Up | this.GestureDirection == UISwipeGestureRecognizerDirection.Down) && canScroll)
            {
                var offsetFrame = new CGRect(new CGPoint(this.Frame.X, this.Frame.Location.Y + (gestureEndPoint.Y - this.GestureStartPoint.Y)), this.Frame.Size);

                this.Frame = offsetFrame;
            }
            else if (this.GestureDirection == UISwipeGestureRecognizerDirection.Left | this.GestureDirection == UISwipeGestureRecognizerDirection.Right)
            {
                if (this.GestureView.IsEqual(this) | !this.ViewCanSwipe(this.GestureView))
                {
                    return;
                }

                gestureEndPoint = touch.LocationInView(this.GestureView);

                var offsetFrame = new CGRect(new CGPoint(this.GestureView.Frame.X + (gestureEndPoint.X - this.GestureStartPoint.X), this.GestureView.Frame.Y), this.GestureView.Frame.Size);
                this.GestureView.Frame = offsetFrame;

                if (this.GestureView.Alpha > 0.4)
                {
                    this.GestureView.Alpha = this.GestureView.Alpha - 0.03f;
                }
            }
        }
        public override void TouchesBegan(NSSet touches, UIEvent evt)
        {
            base.TouchesBegan(touches, evt);

            // If Multitouch is enabled, report the number of fingers down
            TouchStatus.Text = string.Format("Number of fingers {0}", touches.Count);

            // Get the current touch
            UITouch touch = touches.AnyObject as UITouch;

            if (touch != null)
            {
                // Check to see if any of the images have been touched
                if (TouchImage.Frame.Contains(touch.LocationInView(TouchView)))
                {
                    // Fist image touched
                    TouchImage.Image = UIImage.FromBundle("TouchMe_Touched.png");
                    TouchStatus.Text = "Touches Began";
                }
                else if (touch.TapCount == 2 && DoubleTouchImage.Frame.Contains(touch.LocationInView(TouchView)))
                {
                    // Second image double-tapped, toggle bitmap
                    if (imageHighlighted)
                    {
                        DoubleTouchImage.Image = UIImage.FromBundle("DoubleTapMe.png");
                        TouchStatus.Text       = "Double-Tapped Off";
                    }
                    else
                    {
                        DoubleTouchImage.Image = UIImage.FromBundle("DoubleTapMe_Highlighted.png");
                        TouchStatus.Text       = "Double-Tapped On";
                    }
                    imageHighlighted = !imageHighlighted;
                }
                else if (DragImage.Frame.Contains(touch.LocationInView(View)))
                {
                    // Third image touched, prepare to drag
                    touchStartedInside = true;
                }
            }
        }
        public override bool ShouldReceiveTouch(UIGestureRecognizer recognizer, UITouch touch)
        {
            if (recognizer.View.IsDescendantOfView(touch.View))
            {
                return(true);
            }

            if (recognizer.View is not IVisualNativeElementRenderer elementRenderer ||
                elementRenderer.Control == null)
            {
                return(false);
            }

            if (elementRenderer.Control == touch.View ||
                elementRenderer.Control.Subviews.Any(view => view == touch.View))
            {
                return(true);
            }

            return(false);
        }
Ejemplo n.º 36
0
        public override bool BeginTracking(UITouch touch, UIEvent uievent)
        {
            _previousTouchPoint = (CGPoint)touch.LocationInView((UIView)this);

            // hit test the knob layers
            if (_lowerKnobLayer.PaintFrame.Contains(_previousTouchPoint))
            {
                _lowerKnobLayer.Highlighted = true;
                _lowerKnobLayer.SetNeedsDisplay();
            }
            else if (_upperKnobLayer.PaintFrame.Contains(_previousTouchPoint))
            {
                _upperKnobLayer.Highlighted = true;
                _upperKnobLayer.SetNeedsDisplay();
            }

            RawHighValue = HighValue;
            RawLowValue  = LowValue;

            return(_upperKnobLayer.Highlighted || _lowerKnobLayer.Highlighted);
        }
        public override void TouchesBegan(NSSet touches, UIEvent evt)
        {
            if (trackedTouch == null)
            {
                trackedTouch     = (UITouch)touches.FirstOrDefault();
                initialTimestamp = trackedTouch.Timestamp;

                if (!IsForPencil)
                {
                    BeginIfNeeded(null);
                }
                fingerStartTimer = NSTimer.CreateScheduledTimer(cancellationTimeInterval, BeginIfNeeded);
            }
            if (Append(Touches(touches), evt))
            {
                if (IsForPencil)
                {
                    State = Began;
                }
            }
        }
Ejemplo n.º 38
0
        public override bool ContinueTracking(UITouch touch, UIEvent uievent)
        {
            CGPoint point = touch.LocationInView(this);

            percent = (point.X - knobWidth / 2.0f) / (Bounds.Width - knobWidth);
            if (percent < 0.0f)
            {
                percent = 0.0f;
            }
            if (percent > 1.0f)
            {
                percent = 1.0f;
            }
            if ((oldPercent < 0.25f && percent > 0.5f) || (oldPercent > 0.75f && percent < 0.5f))
            {
                mustFlip = false;
            }
            SetNeedsDisplay();
            SendActionForControlEvents(UIControlEvent.TouchDragInside);
            return(true);
        }
Ejemplo n.º 39
0
        private void handleUITouch(UITouch touch)
        {
            var location = touch.LocationInView(null);

            PendingInputs.Enqueue(new MousePositionAbsoluteInput {
                Position = new Vector2((float)location.X * view.Scale, (float)location.Y * view.Scale)
            });

            switch (touch.Phase)
            {
            case UITouchPhase.Moved:
            case UITouchPhase.Began:
                PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Left, true));
                break;

            case UITouchPhase.Cancelled:
            case UITouchPhase.Ended:
                PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Left, false));
                break;
            }
        }
Ejemplo n.º 40
0
		public LinePoint (UITouch touch, int sequenceNumber, PointType pointType)
		{
			SequenceNumber = sequenceNumber;
			Type = touch.Type;
			PointType = pointType;

			Timestamp = touch.Timestamp;
			var view = touch.View;
			Location = touch.LocationInView (view);
			PreciseLocation = touch.GetPreciseLocation (view);
			AzimuthAngle = touch.GetAzimuthAngle (view);
			EstimatedProperties = touch.EstimatedProperties;
			EstimatedPropertiesExpectingUpdates = touch.EstimatedPropertiesExpectingUpdates;
			AltitudeAngle = touch.AltitudeAngle;
			Force = (Type == UITouchType.Stylus || touch.Force > 0) ? touch.Force : 1f;

			if (EstimatedPropertiesExpectingUpdates != 0)
				PointType = this.PointType.Add (PointType.NeedsUpdate);

			EstimationUpdateIndex = touch.EstimationUpdateIndex;
		}
Ejemplo n.º 41
0
        public override void TouchesMoved(NSSet touches, UIEvent evt)
        {
            CanvasView.DrawTouches(touches, evt);
            var touch = (UITouch)touches.FirstOrDefault();

            if (touch == null)
            {
                return;
            }

            UpdateReticleView(touch);

            // Use the last predicted touch to update the reticle.
            UITouch[] predictedTouches = evt?.GetPredictedTouches(touch);
            UITouch   predictedTouch   = predictedTouches?.LastOrDefault();

            if (predictedTouch != null)
            {
                UpdateReticleView(predictedTouch, true);
            }
        }
Ejemplo n.º 42
0
        public override void TouchesEnded(NSSet touches, UIEvent evt)
        {
            UITouch touch = touches.AnyObject as UITouch;

            //Obtain the location of the touch and add it to the current path and current_points array.
            CGPoint touchLocation = touch.LocationInView(this);

            currentPath.AddLineTo(touchLocation);
            currentPoints.Add(touchLocation);

            //Obtain the smoothed path and the points array for that path.
            currentPath = smoothedPathWithGranularity(40, out currentPoints);
            //Add the smoothed path and points array to their Lists.
            paths.Add(currentPath);
            points.Add(currentPoints.ToArray());

            //Obtain the image for the imported signature and display it in the image view.
            imageView.Image = GetImage(false);
            updateBounds(touchLocation);
            SetNeedsDisplay();
        }
Ejemplo n.º 43
0
        public override void TouchesMoved(NSSet touches, UIEvent evt)
        {
            base.TouchesMoved(touches, evt);

            UITouch touch = touches.AnyObject as UITouch;
            PointF  point = touch.LocationInView(this);

            float dx = point.X - Centre.X;
            float dy = point.Y - Centre.Y;
            float r2 = dx * dx + dy * dy;

            iOutsideOuter = (r2 > iOuterRadius * iOuterRadius);
            iOutsideInner = (r2 > iInnerRadius * iInnerRadius);

            if (iTouchedOuter /*&& iOutsideInner*/)
            {
                UpdateAngle(point);
            }

            SetNeedsDisplay();
        }
        // handle touch events
        public override void TouchesEnded(NSSet touches, UIEvent evt)
        {
            base.TouchesEnded(touches, evt);

            // Get the touch that was activated within the view
            UITouch myTouch = (UITouch)touches.AnyObject;

            if (gameTileImagesArray.Contains(myTouch.View) && selAllowed)
            {
                // get the image at the postion within the view
                UIImageView gameBoardTile = (UIImageView)myTouch.View;

                // Get the index of the image within out array
                int tileIndex  = gameTileImagesArray.IndexOf(gameBoardTile);
                int imageIndex = (tileIndex < gameBoardSize ? tileIndex :
                                  tileIndex - gameBoardSize);

                // call our instance method to handle flipping of the chosen tiles
                flipGameBoardTiles(gameBoardTile, tileIndex, imageIndex);
            }
        }
 private bool chart_clickBackGround(UIGestureRecognizer recognizer, UITouch touch)
 {
     //Console.WriteLine("BackGround clicked");
     return false;
 }
		void UpdateReticleView (UITouch touch, bool predicated = false)
		{
			if (touch == null)
				return;

			ReticleView.PredictedDotLayer.Hidden = !predicated;
			ReticleView.PredictedLineLayer.Hidden = !predicated;

			ReticleView.Center = touch.LocationInView (touch.View);

			var azimuthAngle = touch.GetAzimuthAngle (touch.View);
			var azimuthUnitVector = touch.GetAzimuthUnitVector (touch.View);
			var altitudeAngle = touch.AltitudeAngle;

			if (predicated) {
				ReticleView.PredictedAzimuthAngle = azimuthAngle;
				ReticleView.PredictedAzimuthUnitVector = azimuthUnitVector;
				ReticleView.PredictedAzimuthAngle = altitudeAngle;
			} else {
				ReticleView.ActualAzimuthAngle = azimuthAngle;
				ReticleView.ActualAzimuthUnitVector = azimuthUnitVector;
				ReticleView.ActualAzimuthAngle = altitudeAngle;
			}
		}
		bool ShouldReceiveTouch (UIGestureRecognizer gestureRecognizer, UITouch touch)
		{
			if (touch.View != View)
				return false;

			return true;
		}
 internal bool shouldReceiveTouch(UIGestureRecognizer gesture, UITouch touch)
 {
     if (ShouldReceiveTouch != null)
         return ShouldReceiveTouch(gesture, touch);
     return true;
 }
		public bool  beginTrackingWithTouch( UITouch  touch ,/*withEvent*/  UIEvent  @event){
			bool  begins = base.BeginTracking(touch ,/*withEvent*/ @event);
			/*const*/ double continuousPressTimeInterval = this.continuousPressTimeInterval;

			if (begins && continuousPressTimeInterval > 0f) {
				this._beginContinuousPressDelayed();
			}

			return begins;
		}
Ejemplo n.º 50
0
 internal void RemoveTouch(UITouch touch)
 {
     if(touchState.ContainsKey(touch.Handle))
             touchState.Remove(touch.Handle);
 }
Ejemplo n.º 51
0
		public override bool BeginTracking (UITouch uitouch, UIEvent uievent)
		{
			SetNeedsDisplay ();
			isPressed = true;
			return base.BeginTracking (uitouch, uievent);
		}
Ejemplo n.º 52
0
        UISwipeGestureRecognizerDirection GetGestureDirectionWithTouch(UITouch touch)
        {
            CGPoint gestureEndPoint = touch.LocationInView(this);
            double dx = Math.Abs(this.GestureStartPoint.X - gestureEndPoint.X);
            nfloat dy = -1 * (gestureEndPoint.Y - this.GestureStartPoint.Y);

            if (dx > 20)
            {
                return UISwipeGestureRecognizerDirection.Right;
            }

            if (dy < 0)
            {
                return UISwipeGestureRecognizerDirection.Down;
            }
            else if (dy > 0)
            {
                return UISwipeGestureRecognizerDirection.Up;
            }

            return UISwipeGestureRecognizerDirection.Down;
        }
		public override void TouchesBegan (NSSet touches, UIEvent evt)
		{
			if (trackedTouch == null) {
				trackedTouch = (UITouch)touches.FirstOrDefault ();
				initialTimestamp = trackedTouch.Timestamp;

				if (!IsForPencil)
					BeginIfNeeded (null);
					fingerStartTimer = NSTimer.CreateScheduledTimer (cancellationTimeInterval, BeginIfNeeded);
			}
			if (Append (Touches(touches), evt)) {
				if (IsForPencil)
					State = Began;
			}
		}
		void Collect (Stroke stroke, UITouch touch, UIView view, bool coalesced, bool predicted)
		{
			if (view == null)
				throw new ArgumentNullException ();

			// Only collect samples that actually moved in 2D space.
			var location = touch.GetPreciseLocation (view);
			var previousSample = stroke.Samples.LastOrDefault ();
			if (Distance (previousSample?.Location, location) < 0.003)
				return;

			var sample = new StrokeSample {
				Timestamp = touch.Timestamp,
				Location = location,
				Coalesced = coalesced,
				Predicted = predicted
			};
			bool collectForce = touch.Type == UITouchType.Stylus || view.TraitCollection.ForceTouchCapability == UIForceTouchCapability.Available;
			if (collectForce)
				sample.Force = touch.Force;

			if (touch.Type == UITouchType.Stylus) {
				var estimatedProperties = touch.EstimatedProperties;
				sample.EstimatedProperties = estimatedProperties;
				sample.EstimatedPropertiesExpectingUpdates = touch.EstimatedPropertiesExpectingUpdates;
				sample.Altitude = touch.AltitudeAngle;
				sample.Azimuth = touch.GetAzimuthAngle (view);

				if (stroke.Samples.Count == 0 && estimatedProperties.HasFlag (UITouchProperties.Azimuth)) {
					stroke.ExpectsAltitudeAzimuthBackfill = true;
				} else if (stroke.ExpectsAltitudeAzimuthBackfill &&
						   !estimatedProperties.HasFlag (UITouchProperties.Azimuth)) {
					for (int index = 0; index < stroke.Samples.Count; index++) {
						var priorSample = stroke.Samples [index];
						var updatedSample = priorSample;

						if (updatedSample.EstimatedProperties.HasFlag (UITouchProperties.Altitude)) {
							updatedSample.EstimatedProperties &= ~UITouchProperties.Altitude;
							updatedSample.Altitude = sample.Altitude;
						}
						if (updatedSample.EstimatedProperties.HasFlag (UITouchProperties.Azimuth)) {
							updatedSample.EstimatedProperties &= ~UITouchProperties.Azimuth;
							updatedSample.Azimuth = sample.Azimuth;
						}
						stroke.Update (updatedSample, index);
					}
					stroke.ExpectsAltitudeAzimuthBackfill = false;
				}
			}

			if (predicted) {
				stroke.AddPredicted (sample);
			} else {
				var index = stroke.Add (sample);
				if (touch.EstimatedPropertiesExpectingUpdates != 0) {
					outstandingUpdateIndexes [touch.EstimationUpdateIndex] = new StrokeIndex {
						Stroke = stroke,
						Index = index
					};
				}
			}
		}
Ejemplo n.º 55
0
 public override bool BeginTracking(UITouch uitouch, UIEvent uievent)
 {
     return Wrap.Function("BeginTracking", delegate()
     {
         if (SelectedToken != null && uitouch.View == this)
         {
             this.DeselectSelectedToken();
         }
         return base.BeginTracking(uitouch, uievent);
     });
 }
		public void endTrackingWithTouch( UITouch  touch ,/*withEvent*/  UIEvent   @event){
			base.EndTracking(touch ,/*withEvent*/ @event);
			this._cancelContinousPressIfNeeded();
		}
Ejemplo n.º 57
0
 public override bool ContinueTracking(UITouch uitouch, UIEvent uievent)
 {
     var touch = uievent.AllTouches.AnyObject as UITouch;
     if (touch != null) pressed = Bounds.Contains(touch.LocationInView(this));
     return base.ContinueTracking(uitouch, uievent);
 }
Ejemplo n.º 58
0
		bool OnShouldReceiveTouch(UIGestureRecognizer recognizer, UITouch touch)
		{
			foreach (UIView v in ViewAndSuperviewsOfView(touch.View))
			{
				if (v is UITableView || v is UITableViewCell || v.CanBecomeFirstResponder)
					return false;
			}
			return true;
		}
		public override void Reset ()
		{
			Stroke = new Stroke ();
			trackedTouch = null;

			var timer = fingerStartTimer;
			if (timer != null) {
				timer.Invalidate ();
				fingerStartTimer = null;
			}

			base.Reset ();
		}
Ejemplo n.º 60
0
 internal void UpdateTouch(UITouch touch, object theObject)
 {
     if(touchState.ContainsKey(touch.Handle))
             touchState[touch.Handle] = theObject;
         else
             touchState.Add(touch.Handle,theObject);
 }