private void StrokeInput_StrokeStarted(InkStrokeInput sender, PointerEventArgs args)
 {
     ClearSelection();
     inkCanvas.InkPresenter.UnprocessedInput.PointerPressed -= UnprocessedInput_PointerPressed;
     inkCanvas.InkPresenter.UnprocessedInput.PointerMoved -= UnprocessedInput_PointerMoved;
     inkCanvas.InkPresenter.UnprocessedInput.PointerReleased -= UnprocessedInput_PointerReleased;
 }

 private void OnPointerReleased(DrawingSurfaceManipulationHost sender, PointerEventArgs args)
 {
     if (this.PointerReleased != null)
     {
         this.PointerReleased(sender, args);
     }
 }

		private void pointerMoved(CoreWindow sender, PointerEventArgs e)
		{
			theEvent.Type = ApplicationEventTypes.MouseMove;
			var loc = e.CurrentPoint.RawPosition;
			theEvent.CursorPosition = new Point2((int)loc.X, (int)loc.Y);
			handleEvent(theEvent);
		}

 void OnPointerMoved(CoreWindow sender, PointerEventArgs args)
 {
     try
     {
         gestureRecognizer.ProcessMoveEvents(args.GetIntermediatePoints());
     }
     catch (System.Exception e)
     {
         System.Diagnostics.Debug.WriteLine("Lets do the time warp again.");
     }
 }

 void OnPointerReleased(CoreWindow sender, PointerEventArgs args)
 {
     try
     {
         gestureRecognizer.ProcessUpEvent(args.CurrentPoint);
     }
     catch (System.Exception e)
     {
         System.Diagnostics.Debug.WriteLine("Let's do yet another time warp.");
     }
 }

 void PointerMoved(CoreWindow sender, PointerEventArgs args)
 {
     if (args.CurrentPoint.PointerDevice.PointerDeviceType == PointerDeviceType.Mouse)
     {
         var tmp = args.CurrentPoint.RawPosition;
         var dx = tmp.X - buffer.X;
         var dy = tmp.Y - buffer.Y;
         Distance += Math.Sqrt(dx * dx + dy * dy);
         buffer = tmp;
     }
 }

 //Used to check if the pointer is within the bounds of the edit control.
 //If it is, focus should go to the edit control.  If it is outside the bounds
 //Focus should not be in the edit control.
 private void Page_PointerPressed(CoreWindow sender, PointerEventArgs args)
 {
     Rect _boundingbox = EditControl.GetLayout();
     if (_boundingbox.Contains(args.CurrentPoint.Position))
     {
         _textEditContext.InternalSetFocus();
         EditControl.Focus(FocusState.Programmatic);
     }
     else
     {
         _textEditContext.InternalRemoveFocus();
     }
 }

 void UpdateIntermediatePoints(PointerEventArgs args)
 {
     foreach (var point in args.GetIntermediatePoints())
     {
         if (point.IsInContact)
         {
             currentPointsInContact[point.PointerId] = point.Position;
         }
         else
         {
             currentPointsInContact.Remove(point.PointerId);
         }
     }
 }

        /// <summary>
        /// Invoked on every mouse click, touch screen tap, or equivalent interaction when this
        /// page is active and occupies the entire window.  Used to detect browser-style next and
        /// previous mouse button clicks to navigate between pages.
        /// </summary>
        /// <param name="sender">Instance that triggered the event.</param>
        /// <param name="e">Event data describing the conditions that led to the event.</param>
        private void CoreWindow_PointerPressed(CoreWindow sender, PointerEventArgs e)
        {
            var properties = e.CurrentPoint.Properties;

            // Ignore button chords with the left, right, and middle buttons
            if (properties.IsLeftButtonPressed || properties.IsRightButtonPressed ||
                properties.IsMiddleButtonPressed)
                return;

            // If back or foward are pressed (but not both) navigate appropriately
            bool backPressed = properties.IsXButton1Pressed;
            bool forwardPressed = properties.IsXButton2Pressed;
            if (backPressed ^ forwardPressed)
            {
                e.Handled = true;
                if (backPressed) RaisePointerGoBackGestured();
                if (forwardPressed) RaisePointerGoForwardGestured();
            }
        }

        //------------------------------------------------------------------------------
        //
        // VisualProperties.OnPointerPressed
        //
        // This method is called when the user touches the screen, taps it with a stylus
        // or clicks the mouse.
        //
        //------------------------------------------------------------------------------

        void OnPointerPressed(CoreWindow window, PointerEventArgs args)
        {
            Point position = args.CurrentPoint.Position;

            //
            // Walk our list of visuals to determine who, if anybody, was selected
            //
            foreach (var child in _root.Children)
            {
                //
                // Did we hit this child?
                //
                Vector3 offset = child.Offset;
                Vector2 size = child.Size;

                if ((position.X >= offset.X) &&
                    (position.X < offset.X + size.X) &&
                    (position.Y >= offset.Y) &&
                    (position.Y < offset.Y + size.Y))
                {
                    //
                    // This child was hit. Since the children are stored back to front,
                    // the last one hit is the front-most one so it wins
                    //
                    _currentVisual = child as ContainerVisual;
                    _offsetBias = new Vector2((float)(offset.X - position.X),
                                              (float)(offset.Y - position.Y));
                }
            }

            //
            // If a visual was hit, bring it to the front of the Z order
            //
            if (_currentVisual != null)
            {
                ContainerVisual parent = _currentVisual.Parent as ContainerVisual;
                parent.Children.Remove(_currentVisual);
                parent.Children.InsertAtTop(_currentVisual);
            }
        }

		private void pointerPressed(CoreWindow sender, PointerEventArgs e)
		{
			if (e.CurrentPoint.Properties.IsLeftButtonPressed)
			{
				theEvent.Type = ApplicationEventTypes.LeftMouseDown;
				leftPointerOn = true;
			}
			else if (e.CurrentPoint.Properties.IsMiddleButtonPressed)
			{
				theEvent.Type = ApplicationEventTypes.MiddleMouseDown;
				middlePointerOn = true;
			}
			else if (e.CurrentPoint.Properties.IsRightButtonPressed)
			{
				theEvent.Type = ApplicationEventTypes.RightMouseDown;
				rightPointerOn = true;
			}
			
			var loc = e.CurrentPoint.RawPosition;
			theEvent.CursorPosition = new Point2((int)loc.X, (int)loc.Y);
			handleEvent(theEvent);
		}

        /// <summary>
        /// Se invoca en cada clic del mouse, punteo en la pantalla táctil o una interacción equivalente cuando esta
        /// página está activa y ocupa toda la ventana.  Se usa para detectar los clics de botón del mouse
        /// siguiente y anterior del estilo del explorador para navegar entre páginas.
        /// </summary>
        /// <param name="sender">Instancia que desencadena el evento.</param>
        /// <param name="e">Datos de evento que describen las condiciones que dan lugar al evento.</param>
        private void CoreWindow_PointerPressed(CoreWindow sender,
            PointerEventArgs e)
        {
            var properties = e.CurrentPoint.Properties;

            // Omitir la presión simultánea de botones con los botones Izquierda, Derecha y Medio
            if (properties.IsLeftButtonPressed || properties.IsRightButtonPressed ||
                properties.IsMiddleButtonPressed) return;

            // Si se presiona Repág o Avpág (pero no ambos), navegar adecuadamente
            bool backPressed = properties.IsXButton1Pressed;
            bool forwardPressed = properties.IsXButton2Pressed;
            if (backPressed ^ forwardPressed)
            {
                e.Handled = true;
                if (backPressed) this.GoBackCommand.Execute(null);
                if (forwardPressed) this.GoForwardCommand.Execute(null);
            }
        }

        private void OnCoreWindowPointerReleased(CoreWindow sender, PointerEventArgs args)
        {
            if (args.CurrentPoint.PointerDevice.PointerDeviceType == PointerDeviceType.Mouse &&
                !args.CurrentPoint.Properties.IsLeftButtonPressed &&
                !args.CurrentPoint.Properties.IsMiddleButtonPressed &&
                _rightMouseButtonPressed)
            {
                OnSwitchGesture();
                args.Handled = true;
            }

            _rightMouseButtonPressed = false;
        } 

        private void OnCoreWindowPointerPressed(CoreWindow sender, PointerEventArgs args)
        {
            if (this.IsLightDismissEnabled &&
                this.CanDismiss && 
                this.IsOpen &&
                Window.Current != null &&
                Window.Current.Content != null)
            {
                var windowToAppBarTransform = Window.Current.Content.TransformToVisual(this);
                var appBarPosition = windowToAppBarTransform.TransformPoint(args.CurrentPoint.Position);
                var appBarBounds = this.GetBoundingRect(this);

                if (!appBarBounds.Contains(appBarPosition))
                {
                    this.IsOpen = false;
                    return;
                }
            }

            if (args.CurrentPoint.PointerDevice.PointerDeviceType == PointerDeviceType.Mouse)
            {
                _rightMouseButtonPressed =
                    args.CurrentPoint.Properties.IsRightButtonPressed &&
                    !args.CurrentPoint.Properties.IsLeftButtonPressed &&
                    !args.CurrentPoint.Properties.IsMiddleButtonPressed;

                if (_rightMouseButtonPressed)
                {
                    args.Handled = true;
                }
            }
        } 

 // Call the gesture recognizer when a pointer event occurs
 void OnPointerPressed(CoreWindow sender, PointerEventArgs args)
 {
     gestureRecognizer.ProcessDownEvent(args.CurrentPoint);
 }

        //------------------------------------------------------------------------------
        //
        // VisualProperties.OnPointerMoved
        //
        // This method is called when the user moves their finger, stylus or mouse with
        // a button pressed over the screen.
        //
        //------------------------------------------------------------------------------

        void OnPointerMoved(CoreWindow window, PointerEventArgs args)
        {
            //
            // If a visual is selected, drag it with the pointer position and
            // make it opaque while we drag it
            //
            if (_currentVisual != null)
            {
                //
                // Set up the properties of the visual the first time it is
                // dragged. This will last for the duration of the drag
                //
                if (!_dragging)
                {
                    _currentVisual.Opacity = 1.0f;

                    //
                    // Transform the first child of the current visual so that
                    // the image is rotated
                    //
                    foreach (var child in _currentVisual.Children)
                    {
                        child.RotationAngleInDegrees = 45.0f;
                        child.CenterPoint = new Vector3(_currentVisual.Size.X / 2, _currentVisual.Size.Y / 2, 0);
                        break;
                    }

                    //
                    // Clip the visual to its original layout rect by using an inset
                    // clip with a one-pixel margin all around
                    //
                    var clip = _compositor.CreateInsetClip();
                    clip.LeftInset = 1.0f;
                    clip.RightInset = 1.0f;
                    clip.TopInset = 1.0f;
                    clip.BottomInset = 1.0f;
                    _currentVisual.Clip = clip;

                    _dragging = true;
                }

                Point position = args.CurrentPoint.Position;
                _currentVisual.Offset = new Vector3((float)(position.X + _offsetBias.X),
                                                    (float)(position.Y + _offsetBias.Y),
                                                    0.0f);
            }
        }

 private void coreWindow_PointerMoved(CoreWindow sender, PointerEventArgs args)
 {
     PincodeManager.StartIdleTimer();
 }

 private void Input_PointerMoved(object sender, PointerEventArgs args)
 {
     gestureRecognizer.ProcessMoveEvents(args.GetIntermediatePoints());
     args.Handled = true;
 }

        /// <summary>
        /// Invoked on every mouse click, touch screen tap, or equivalent interaction when this
        /// page is active and occupies the entire window.  Used to detect browser-style next and
        /// previous mouse button clicks to navigate between pages.
        /// </summary>
        /// <param name="sender">Instance that triggered the event.</param>
        /// <param name="args">Event data describing the conditions that led to the event.</param>
        private void CoreWindow_PointerPressed(CoreWindow sender, PointerEventArgs args)
        {
            var properties = args.CurrentPoint.Properties;

            // Ignore button chords with the left, right, and middle buttons
            if (properties.IsLeftButtonPressed || properties.IsRightButtonPressed || properties.IsMiddleButtonPressed)
            {
                return;
            }

            // If back or foward are pressed (but not both) navigate appropriately
            var backPressed = properties.IsXButton1Pressed;
            var forwardPressed = properties.IsXButton2Pressed;
            if (backPressed ^ forwardPressed)
            {
                args.Handled = true;
                if (backPressed)
                {
                    GoBack(this, new RoutedEventArgs());
                }

                if (forwardPressed)
                {
                    GoForward(this, new RoutedEventArgs());
                }
            }
        }

 void OnPointerReleased(CoreWindow sender, PointerEventArgs args)
 {
     gestureRecognizer.ProcessUpEvent(args.CurrentPoint);
 }