/** * Send an event upwards. If no target is specified, the event is sent to * the object itself. * * @param cb The event being sent * @param customTarget the event receiver, if any */ protected void issueEvent <T>(ExecEv.EventFunction <T> cb, GO customTarget = null) where T : Handler { if (customTarget != null) { ExecEv.ExecuteHierarchy <T>(customTarget, null, cb); } else { ExecEv.ExecuteHierarchy <T>(this.gameObject, null, cb); } }
/// <summary> /// Swipe 이벤트 실행 /// </summary> /// <param name="function"></param> public void ExecuteSwipeEvent(ExecuteEvents.EventFunction<IFSNSwipeHandler> function) { foreach (var handler in m_swipeHandlers) { ExecuteEvents.ExecuteHierarchy<IFSNSwipeHandler>(handler, null, function); } }
/// <summary> /// 전환 스킵 이벤트 호출 /// </summary> /// <param name="function"></param> public void ExecuteSkipTransitionEvent(ExecuteEvents.EventFunction<IFSNSkipTransitionHandler> function) { // NOTE : 현재는 swipe handler 와 통합해서 사용중임. 나중에 분리해야할 때 분리할 것 foreach (var handler in m_swipeHandlers) { ExecuteEvents.ExecuteHierarchy<IFSNSkipTransitionHandler>(handler, null, function); } }
/** * Send an event to the root game object (which must be manually set). * * @param cb The event being sent */ protected void rootEvent <T>(ExecEv.EventFunction <T> cb) where T : Handler { ExecEv.ExecuteHierarchy <T>(root, null, cb); }
/// <summary> /// Process the current mouse press. /// </summary> private void ProcessMousePress(MouseButtonEventData data) { var pointerEvent = data.buttonData; var currentOverGo = pointerEvent.pointerCurrentRaycast.gameObject; // PointerDown notification if (data.PressedThisFrame()) { pointerEvent.eligibleForClick = true; pointerEvent.delta = Vector2.zero; pointerEvent.dragging = false; pointerEvent.useDragThreshold = true; pointerEvent.pressPosition = pointerEvent.position; pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast; DeselectIfSelectionChanged(currentOverGo, pointerEvent); // search for the control that will receive the press // if we can't find a press handler set the press // handler to be what would receive a click. var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.pointerDownHandler); // didnt find a press handler... search for a click handler if (newPressed == null) { newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo); } // Debug.Log("Pressed: " + newPressed); float time = Time.unscaledTime; if (newPressed == pointerEvent.lastPress) { var diffTime = time - pointerEvent.clickTime; if (diffTime < 0.3f) { ++pointerEvent.clickCount; } else { pointerEvent.clickCount = 1; } pointerEvent.clickTime = time; } else { pointerEvent.clickCount = 1; } pointerEvent.pointerPress = newPressed; pointerEvent.rawPointerPress = currentOverGo; pointerEvent.clickTime = time; // Save the drag handler as well pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo); if (pointerEvent.pointerDrag != null) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag); } } // PointerUp notification if (data.ReleasedThisFrame()) { // Debug.Log("Executing pressup on: " + pointer.pointerPress); ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); // Debug.Log("KeyCode: " + pointer.eventData.keyCode); // see if we mouse up on the same element that we clicked on... var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo); // PointerClick and Drop events if (pointerEvent.pointerPress == pointerUpHandler && pointerEvent.eligibleForClick) { ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler); } else if (pointerEvent.pointerDrag != null) { ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.dropHandler); } pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; if (pointerEvent.pointerDrag != null && pointerEvent.dragging) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler); } pointerEvent.dragging = false; pointerEvent.pointerDrag = null; // redo pointer enter / exit to refresh state // so that if we moused over somethign that ignored it before // due to having pressed on something else // it now gets it. if (currentOverGo != pointerEvent.pointerEnter) { HandlePointerExitAndEnter(pointerEvent, null); HandlePointerExitAndEnter(pointerEvent, currentOverGo); } } }
// walk up the tree till a common root between the last entered and the current entered is foung // send exit events up to (but not inluding) the common root. Then send enter events up to // (but not including the common root). protected void HandlePointerExitAndEnter(PointerEventData currentPointerData, GameObject newEnterTarget) { // if we have no target / pointerEnter has been deleted // just send exit events to anything we are tracking // then exit if (newEnterTarget == null || currentPointerData.pointerEnter == null) { for (var i = 0; i < currentPointerData.hovered.Count; ++i) { ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerExitHandler); } currentPointerData.hovered.Clear(); if (newEnterTarget == null) { currentPointerData.pointerEnter = newEnterTarget; return; } } // if we have not changed hover target if (currentPointerData.pointerEnter == newEnterTarget && newEnterTarget) { return; } GameObject commonRoot = FindCommonRoot(currentPointerData.pointerEnter, newEnterTarget); // and we already an entered object from last time if (currentPointerData.pointerEnter != null) { // send exit handler call to all elements in the chain // until we reach the new target, or null! Transform t = currentPointerData.pointerEnter.transform; while (t != null) { // if we reach the common root break out! if (commonRoot != null && commonRoot.transform == t) { break; } ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerExitHandler); currentPointerData.hovered.Remove(t.gameObject); t = t.parent; } } // now issue the enter call up to but not including the common root currentPointerData.pointerEnter = newEnterTarget; if (newEnterTarget != null) { Transform t = newEnterTarget.transform; while (t != null && t.gameObject != commonRoot) { ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerEnterHandler); currentPointerData.hovered.Add(t.gameObject); t = t.parent; } } }
// walk up the tree till a common root between the last entered and the current entered is foung // send exit events up to (but not inluding) the common root. Then send enter events up to // (but not including the common root). protected void HandlePointerExitAndEnter(PointerEventData currentPointerData, GameObject newEnterTarget) { // 处理触点是否进入新的物体 // 如果进入未空或者触点的进入体为空,则将触点中的 hovered对象 全部执行"出点"操作 // 若两者均为空 或 两者相同 则没有发生 新的进入事件 return //两者不同,确认两者是否存在共同根节点CommonRoot //旧的进入点 到 CommonRoot 前的所有 hovered对象 执行 出点 //将新节点设置为 进入点, 新节点 至 CommonRoot 前的对象添加进hovered中并执行 进点 操作 // if we have no target / pointerEnter has been deleted // just send exit events to anything we are tracking // then exit if (newEnterTarget == null || currentPointerData.pointerEnter == null) { for (var i = 0; i < currentPointerData.hovered.Count; ++i) { ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerExitHandler); } currentPointerData.hovered.Clear(); if (newEnterTarget == null) { currentPointerData.pointerEnter = newEnterTarget; return; } } // if we have not changed hover target if (currentPointerData.pointerEnter == newEnterTarget && newEnterTarget) { return; } GameObject commonRoot = FindCommonRoot(currentPointerData.pointerEnter, newEnterTarget); // and we already an entered object from last time if (currentPointerData.pointerEnter != null) { // send exit handler call to all elements in the chain // until we reach the new target, or null! Transform t = currentPointerData.pointerEnter.transform; while (t != null) { // if we reach the common root break out! if (commonRoot != null && commonRoot.transform == t) { break; } ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerExitHandler); currentPointerData.hovered.Remove(t.gameObject); t = t.parent; } } // now issue the enter call up to but not including the common root currentPointerData.pointerEnter = newEnterTarget; if (newEnterTarget != null) { Transform t = newEnterTarget.transform; while (t != null && t.gameObject != commonRoot) { ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerEnterHandler); currentPointerData.hovered.Add(t.gameObject); t = t.parent; } } }
protected void ProcessMousePress(PointerInputModule.MouseButtonEventData data) { PointerEventData buttonData = data.buttonData; GameObject gameObject = buttonData.pointerCurrentRaycast.gameObject; if (data.PressedThisFrame()) { buttonData.eligibleForClick = true; buttonData.delta = Vector2.zero; buttonData.dragging = false; buttonData.useDragThreshold = true; buttonData.pressPosition = buttonData.position; buttonData.pointerPressRaycast = buttonData.pointerCurrentRaycast; base.DeselectIfSelectionChanged(gameObject, buttonData); GameObject eventHandler = ExecuteEvents.ExecuteHierarchy <IPointerDownHandler>(gameObject, buttonData, ExecuteEvents.pointerDownHandler); if (eventHandler == null) { eventHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(gameObject); } float unscaledTime = Time.unscaledTime; if (eventHandler == buttonData.lastPress) { float num2 = unscaledTime - buttonData.clickTime; if (num2 < 0.3f) { buttonData.clickCount++; } else { buttonData.clickCount = 1; } buttonData.clickTime = unscaledTime; } else { buttonData.clickCount = 1; } buttonData.pointerPress = eventHandler; buttonData.rawPointerPress = gameObject; buttonData.clickTime = unscaledTime; buttonData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(gameObject); if (buttonData.pointerDrag != null) { ExecuteEvents.Execute <IInitializePotentialDragHandler>(buttonData.pointerDrag, buttonData, ExecuteEvents.initializePotentialDrag); } } if (data.ReleasedThisFrame()) { ExecuteEvents.Execute <IPointerUpHandler>(buttonData.pointerPress, buttonData, ExecuteEvents.pointerUpHandler); GameObject obj4 = ExecuteEvents.GetEventHandler <IPointerClickHandler>(gameObject); if ((buttonData.pointerPress == obj4) && buttonData.eligibleForClick) { ExecuteEvents.Execute <IPointerClickHandler>(buttonData.pointerPress, buttonData, ExecuteEvents.pointerClickHandler); } else if ((buttonData.pointerDrag != null) && buttonData.dragging) { ExecuteEvents.ExecuteHierarchy <IDropHandler>(gameObject, buttonData, ExecuteEvents.dropHandler); } buttonData.eligibleForClick = false; buttonData.pointerPress = null; buttonData.rawPointerPress = null; if ((buttonData.pointerDrag != null) && buttonData.dragging) { ExecuteEvents.Execute <IEndDragHandler>(buttonData.pointerDrag, buttonData, ExecuteEvents.endDragHandler); } buttonData.dragging = false; buttonData.pointerDrag = null; if (gameObject != buttonData.pointerEnter) { base.HandlePointerExitAndEnter(buttonData, null); base.HandlePointerExitAndEnter(buttonData, gameObject); } } }
public override void Process() { GuiHit = false; //ButtonUsed = false; // send update events if there is a selected object - this is important for InputField to receive keyboard events SendUpdateEventToSelectedObject(); if (ArbitraryInput.instances != null) { foreach (ArbitraryInput pointer in ArbitraryInput.instances) { //Check if the Pointer is Active in the heirarchy. If it isn't, turn off the cursor and continue if (pointer.gameObject.activeInHierarchy == false) { pointer.isHittingUI = false; continue; } UpdateCameraPosition(pointer); bool hit = GetLookPointerEventData(pointer); if (hit == false) { continue; } pointer.CurrentPoint = pointer.PointEvent.pointerCurrentRaycast.gameObject; // handle enter and exit events (highlight) base.HandlePointerExitAndEnter(pointer.PointEvent, pointer.CurrentPoint); UpdateCursor(pointer, pointer.PointEvent); if (pointer != null) { if (pointer.buttonDown) { ClearSelection(); pointer.PointEvent.pressPosition = pointer.PointEvent.position; pointer.PointEvent.pointerPressRaycast = pointer.PointEvent.pointerCurrentRaycast; pointer.PointEvent.pointerPress = null; if (pointer.CurrentPoint != null) { pointer.CurrentPressed = pointer.CurrentPoint; GameObject newPressed = ExecuteEvents.ExecuteHierarchy(pointer.CurrentPressed.gameObject, pointer.PointEvent, ExecuteEvents.pointerDownHandler); if (newPressed == null) { // some UI elements might only have click handler and not pointer down handler newPressed = ExecuteEvents.ExecuteHierarchy(pointer.CurrentPressed, pointer.PointEvent, ExecuteEvents.pointerClickHandler); if (newPressed != null) { pointer.CurrentPressed = newPressed; } } else { pointer.CurrentPressed = newPressed; // we want to do click on button down at same time, unlike regular mouse processing // which does click when mouse goes up over same object it went down on // reason to do this is head tracking might be jittery and this makes it easier to click buttons ExecuteEvents.Execute(newPressed, pointer.PointEvent, ExecuteEvents.pointerClickHandler); } if (newPressed != null) { pointer.PointEvent.pointerPress = newPressed; pointer.CurrentPressed = newPressed; Select(pointer.CurrentPressed); //ButtonUsed = true; } ExecuteEvents.Execute(pointer.CurrentPressed, pointer.PointEvent, ExecuteEvents.beginDragHandler); pointer.PointEvent.pointerDrag = pointer.CurrentPressed; pointer.CurrentDragging = pointer.CurrentPressed; } } if (pointer.buttonUp) { if (pointer.CurrentDragging) { ExecuteEvents.Execute(pointer.CurrentDragging, pointer.PointEvent, ExecuteEvents.endDragHandler); if (pointer.CurrentPoint != null) { ExecuteEvents.ExecuteHierarchy(pointer.CurrentPoint, pointer.PointEvent, ExecuteEvents.dropHandler); } pointer.PointEvent.pointerDrag = null; pointer.CurrentDragging = null; } if (pointer.CurrentPressed) { ExecuteEvents.Execute(pointer.CurrentPressed, pointer.PointEvent, ExecuteEvents.pointerUpHandler); pointer.PointEvent.rawPointerPress = null; pointer.PointEvent.pointerPress = null; pointer.CurrentPressed = null; } } // drag handling if (pointer.CurrentDragging != null) { ExecuteEvents.Execute(pointer.CurrentDragging, pointer.PointEvent, ExecuteEvents.dragHandler); } } } } }
protected void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released) { GameObject gameObject = pointerEvent.pointerCurrentRaycast.gameObject; if (pressed) { pointerEvent.eligibleForClick = true; pointerEvent.delta = Vector2.zero; pointerEvent.dragging = false; pointerEvent.useDragThreshold = true; pointerEvent.pressPosition = pointerEvent.position; pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast; base.DeselectIfSelectionChanged(gameObject, pointerEvent); if (pointerEvent.pointerEnter != gameObject) { base.HandlePointerExitAndEnter(pointerEvent, gameObject); pointerEvent.pointerEnter = gameObject; } GameObject gameObject2 = ExecuteEvents.ExecuteHierarchy <IPointerDownHandler>(gameObject, pointerEvent, ExecuteEvents.pointerDownHandler); if (gameObject2 == null) { gameObject2 = ExecuteEvents.GetEventHandler <IPointerClickHandler>(gameObject); } float unscaledTime = Time.unscaledTime; if (gameObject2 == pointerEvent.lastPress) { float num = unscaledTime - pointerEvent.clickTime; if (num < 0.3f) { pointerEvent.clickCount++; } else { pointerEvent.clickCount = 1; } pointerEvent.clickTime = unscaledTime; } else { pointerEvent.clickCount = 1; } pointerEvent.pointerPress = gameObject2; pointerEvent.rawPointerPress = gameObject; pointerEvent.clickTime = unscaledTime; pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(gameObject); if (pointerEvent.pointerDrag != null) { ExecuteEvents.Execute <IInitializePotentialDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag); } this.m_InputPointerEvent = pointerEvent; } if (released) { ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); GameObject eventHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(gameObject); if (pointerEvent.pointerPress == eventHandler && pointerEvent.eligibleForClick) { ExecuteEvents.Execute <IPointerClickHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler); } else if (pointerEvent.pointerDrag != null && pointerEvent.dragging) { ExecuteEvents.ExecuteHierarchy <IDropHandler>(gameObject, pointerEvent, ExecuteEvents.dropHandler); } pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; if (pointerEvent.pointerDrag != null && pointerEvent.dragging) { ExecuteEvents.Execute <IEndDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler); } pointerEvent.dragging = false; pointerEvent.pointerDrag = null; if (pointerEvent.pointerDrag != null) { ExecuteEvents.Execute <IEndDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler); } pointerEvent.pointerDrag = null; ExecuteEvents.ExecuteHierarchy <IPointerExitHandler>(pointerEvent.pointerEnter, pointerEvent, ExecuteEvents.pointerExitHandler); pointerEvent.pointerEnter = null; this.m_InputPointerEvent = pointerEvent; } }
protected void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released) { var currentOverGo = pointerEvent.pointerCurrentRaycast.gameObject; // PointerDown notification if (pressed) { pointerEvent.eligibleForClick = true; pointerEvent.delta = Vector2.zero; pointerEvent.dragging = false; pointerEvent.useDragThreshold = true; pointerEvent.pressPosition = pointerEvent.position; pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast; //DeselectIfSelectionChanged(currentOverGo, pointerEvent); if (pointerEvent.pointerEnter != currentOverGo) { // send a pointer enter to the touched element if it isn't the one to select... HandlePointerExitAndEnter(pointerEvent, currentOverGo); pointerEvent.pointerEnter = currentOverGo; } // search for the control that will receive the press // if we can't find a press handler set the press // handler to be what would receive a click. var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.pointerDownHandler); // didnt find a press handler... search for a click handler if (newPressed == null) { newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo); } // Debug.Log("Pressed: " + newPressed); float time = Time.unscaledTime; if (newPressed == pointerEvent.lastPress) { var diffTime = time - pointerEvent.clickTime; if (diffTime < 0.3f) { ++pointerEvent.clickCount; } else { pointerEvent.clickCount = 1; } pointerEvent.clickTime = time; } else { pointerEvent.clickCount = 1; } pointerEvent.pointerPress = newPressed; pointerEvent.rawPointerPress = currentOverGo; pointerEvent.clickTime = time; // Save the drag handler as well pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo); if (pointerEvent.pointerDrag != null) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag); } } // PointerUp notification if (released) { // Debug.Log("Executing pressup on: " + pointer.pointerPress); ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); // Debug.Log("KeyCode: " + pointer.eventData.keyCode); // see if we mouse up on the same element that we clicked on... var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo); // PointerClick and Drop events if (pointerEvent.pointerPress == pointerUpHandler && pointerEvent.eligibleForClick) { ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler); } else if (pointerEvent.pointerDrag != null && pointerEvent.dragging) { ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.dropHandler); } pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; if (pointerEvent.pointerDrag != null && pointerEvent.dragging) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler); } pointerEvent.dragging = false; pointerEvent.pointerDrag = null; // send exit events as we need to simulate this on touch up on touch device ExecuteEvents.ExecuteHierarchy(pointerEvent.pointerEnter, pointerEvent, ExecuteEvents.pointerExitHandler); pointerEvent.pointerEnter = null; } }
/// <summary> /// Calculate and send a move event to the current selected object. /// </summary> /// <returns>If the move event was used by the selected object.</returns> protected bool SendMoveEventToSelectedObject() { float time = Time.unscaledTime; if (!playerInput) { //print("assign playerinput"); return(false); } Vector2 movement = GetRawMoveVector(); if (Mathf.Approximately(movement.x, 0f) && Mathf.Approximately(movement.y, 0f)) { m_ConsecutiveMoveCount = 0; return(false); } // If user pressed key again, always allow event //bool allow = input.GetButtonDown(m_HorizontalAxis) || input.GetButtonDown(m_VerticalAxis); bool allow = playerInput.LeftAxisTilted; bool similarDir = (Vector2.Dot(movement, m_LastMoveVector) > 0); if (allow) { // Otherwise, user held down key or axis. // If direction didn't change at least 90 degrees, wait for delay before allowing consequtive event. if (similarDir && m_ConsecutiveMoveCount == 1) { allow = (time > m_PrevActionTime + m_RepeatDelay); } // If direction changed at least 90 degree, or we already had the delay, repeat at repeat rate. else { allow = (time > m_PrevActionTime + 1f / m_InputActionsPerSecond); } //print(allow); } if (!allow) { return(false); } // Debug.Log(m_ProcessingEvent.rawType + " axis:" + m_AllowAxisEvents + " value:" + "(" + x + "," + y + ")"); var axisEventData = GetAxisEventData(movement.x, movement.y, 0.6f); if (axisEventData.moveDir != MoveDirection.None) { ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, axisEventData, ExecuteEvents.moveHandler); if (!similarDir) { m_ConsecutiveMoveCount = 0; } m_ConsecutiveMoveCount++; m_PrevActionTime = time; m_LastMoveVector = movement; } else { m_ConsecutiveMoveCount = 0; } return(axisEventData.used); }
private void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released) { var currentOverGo = pointerEvent.pointerCurrentRaycast.gameObject; // PointerDown notification if (pressed) { pointerEvent.eligibleForClick = true; pointerEvent.delta = Vector2.zero; pointerEvent.dragging = false; pointerEvent.useDragThreshold = true; pointerEvent.pressPosition = pointerEvent.position; pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast; DeselectIfSelectionChanged(currentOverGo, pointerEvent); if (pointerEvent.pointerEnter != currentOverGo) { // send a pointer enter to the touched element if it isn't the one to select... HandlePointerExitAndEnter(pointerEvent, currentOverGo); pointerEvent.pointerEnter = currentOverGo; } // search for the control that will receive the press var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.pointerDownHandler); // if we can't find a press handler set the press handler to be what would receive a click if (newPressed == null) { newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo); } pointerEvent.pointerPress = newPressed; pointerEvent.rawPointerPress = currentOverGo; // Save the drag handler as well pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo); if (pointerEvent.pointerDrag != null) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag); } } if (released) { ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo); if (pointerEvent.pointerPress == pointerUpHandler && pointerEvent.eligibleForClick) { ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler); } else if (pointerEvent.pointerDrag != null) { ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.dropHandler); } pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; if (pointerEvent.pointerDrag != null && pointerEvent.dragging) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler); } pointerEvent.dragging = false; pointerEvent.pointerDrag = null; if (pointerEvent.pointerDrag != null) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler); } pointerEvent.pointerDrag = null; ExecuteEvents.ExecuteHierarchy(pointerEvent.pointerEnter, pointerEvent, ExecuteEvents.pointerExitHandler); pointerEvent.pointerEnter = null; } }