// Copied from StandaloneInputModule where these are marked private instead of protected in Unity 5.3 / 5.4
#region Unity 5.3 / 5.4 compatibility.
#if UNITY_5_3 || UNITY_5_4
void ProcessTouchPress( PointerEventData pointerEvent, bool pressed, bool released )
{
var go = 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;
DeselectIfSelectionChanged( go, pointerEvent );
if (pointerEvent.pointerEnter != go)
{
HandlePointerExitAndEnter( pointerEvent, go );
pointerEvent.pointerEnter = go;
}
var go2 = ExecuteEvents.ExecuteHierarchy( go, pointerEvent, ExecuteEvents.pointerDownHandler );
if (go2 == null)
{
go2 = ExecuteEvents.GetEventHandler<IPointerClickHandler>( go );
}
float unscaledTime = Time.unscaledTime;
if (go2 == 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 = go2;
pointerEvent.rawPointerPress = go;
pointerEvent.clickTime = unscaledTime;
pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>( go );
if (pointerEvent.pointerDrag != null)
{
ExecuteEvents.Execute( pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag );
}
}
if (released)
{
ExecuteEvents.Execute( pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler );
var eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>( go );
if (pointerEvent.pointerPress == eventHandler && pointerEvent.eligibleForClick)
{
ExecuteEvents.Execute( pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler );
}
else if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
{
ExecuteEvents.ExecuteHierarchy( go, 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;
}
}
public virtual void ProcessUpdated(object sender, PointerEventArgs pointerEventArgs)
{
#if UNITY_5_6_OR_NEWER
uiSampler.Begin();
#endif
var pointers = pointerEventArgs.Pointers;
var raycast = new RaycastResult();
var count = pointers.Count;
for (var i = 0; i < count; i++)
{
var pointer = pointers[i];
var over = pointer.GetOverData();
// Don't update the pointer if it is pressed not over an UI element
if ((pointer.Buttons & Pointer.PointerButtonState.AnyButtonPressed) > 0)
{
var press = pointer.GetPressData();
if (press.Type != HitData.HitType.UI)
{
continue;
}
}
PointerEventData data;
GetPointerData(pointer.Id, out data, true);
// If not over an UI element this and previous frame, don't process further.
// Need to check the previous hover state to properly process leaving a UI element.
if (over.Type != HitData.HitType.UI)
{
if (data.hovered.Count == 0)
{
continue;
}
}
data.Reset();
var target = over.Target;
var currentOverGo = target == null ? null : target.gameObject;
data.position = pointer.Position;
data.delta = pointer.Position - pointer.PreviousPosition;
convertRaycast(over.RaycastHitUI, ref raycast);
raycast.screenPosition = data.position;
data.pointerCurrentRaycast = raycast;
input.HandlePointerExitAndEnter(data, currentOverGo);
bool moving = data.IsPointerMoving();
if (moving && data.pointerDrag != null &&
!data.dragging &&
ShouldStartDrag(data.pressPosition, data.position, input.eventSystem.pixelDragThreshold, data.useDragThreshold))
{
ExecuteEvents.Execute(data.pointerDrag, data, ExecuteEvents.beginDragHandler);
data.dragging = true;
}
// Drag notification
if (data.dragging && moving && data.pointerDrag != null)
{
// Before doing drag we should cancel any pointer down state
// And clear selection!
if (data.pointerPress != data.pointerDrag)
{
ExecuteEvents.Execute(data.pointerPress, data, ExecuteEvents.pointerUpHandler);
data.eligibleForClick = false;
data.pointerPress = null;
data.rawPointerPress = null;
}
ExecuteEvents.Execute(data.pointerDrag, data, ExecuteEvents.dragHandler);
}
var mousePointer = pointer as MousePointer;
if (mousePointer != null && !Mathf.Approximately(mousePointer.ScrollDelta.sqrMagnitude, 0.0f))
{
data.scrollDelta = mousePointer.ScrollDelta;
var scrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(currentOverGo);
ExecuteEvents.ExecuteHierarchy(scrollHandler, data, ExecuteEvents.scrollHandler);
}
}
#if UNITY_5_6_OR_NEWER
uiSampler.End();
#endif
}
public virtual void ProcessReleased(object sender, PointerEventArgs pointerEventArgs)
{
#if UNITY_5_6_OR_NEWER
uiSampler.Begin();
#endif
var pointers = pointerEventArgs.Pointers;
var count = pointers.Count;
for (var i = 0; i < count; i++)
{
var pointer = pointers[i];
var press = pointer.GetPressData();
// Don't update the pointer if it is was not pressed over an UI element
if (press.Type != HitData.HitType.UI)
{
continue;
}
var over = pointer.GetOverData();
PointerEventData data;
GetPointerData(pointer.Id, out data, true);
var target = over.Target;
var currentOverGo = target == null ? null : target.gameObject;
ExecuteEvents.Execute(data.pointerPress, data, ExecuteEvents.pointerUpHandler);
var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
if (data.pointerPress == pointerUpHandler && data.eligibleForClick)
{
ExecuteEvents.Execute(data.pointerPress, data, ExecuteEvents.pointerClickHandler);
}
else if (data.pointerDrag != null && data.dragging)
{
ExecuteEvents.ExecuteHierarchy(currentOverGo, data, ExecuteEvents.dropHandler);
}
data.eligibleForClick = false;
data.pointerPress = null;
data.rawPointerPress = null;
if (data.pointerDrag != null && data.dragging)
{
ExecuteEvents.Execute(data.pointerDrag, data, ExecuteEvents.endDragHandler);
}
data.dragging = false;
data.pointerDrag = null;
// send exit events as we need to simulate this on touch up on touch device
ExecuteEvents.ExecuteHierarchy(data.pointerEnter, data, ExecuteEvents.pointerExitHandler);
data.pointerEnter = 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 != data.pointerEnter)
{
input.HandlePointerExitAndEnter(data, null);
input.HandlePointerExitAndEnter(data, currentOverGo);
}
}
#if UNITY_5_6_OR_NEWER
uiSampler.End();
#endif
}
private void HandleScroll()
{
bool touchDown = false;
bool touching = false;
Vector2 currentScroll = Vector2.zero;
int cidx = -1;
int cidxa = -1;
touchDown |= VRControllers.Instance.GetButtonDown(VRControllerButtons.Touch, out cidx);
touching |= VRControllers.Instance.GetButton(VRControllerButtons.Touch, out cidxa);
if (cidx > -1)
{
currentScroll = VRControllers.Instance.GetTouchPos(cidx);
}
else if (cidxa > -1)
{
currentScroll = VRControllers.Instance.GetTouchPos(cidxa);
}
/*
#if UNITY_HAS_GOOGLEVR && (UNITY_ANDROID || UNITY_EDITOR)
* touchDown |= GvrController.TouchDown;
* touching |= GvrController.IsTouching;
* currentScroll = GvrController.TouchPos;
#endif // UNITY_HAS_GOOGLEVR && (UNITY_ANDROID || UNITY_EDITOR)
*/
if (touchDown && !eligibleForScroll)
{
lastScroll = currentScroll;
eligibleForScroll = true;
}
else if (touching && eligibleForScroll)
{
//Debug.Log("currentScroll is " + currentScroll + " ， lastScroll is " + lastScroll);
pointerData.scrollDelta = (currentScroll - lastScroll) * SCROLL_DELTA_MULTIPLIER;
GameObject currentGameObject = GetCurrentGameObject();
if (currentGameObject != null && !Mathf.Approximately(pointerData.scrollDelta.sqrMagnitude, 0.0f))
{
GameObject scrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(currentGameObject);
ExecuteEvents.ExecuteHierarchy(scrollHandler, pointerData, ExecuteEvents.scrollHandler);
}
if (scrollEventData == null)
{
scrollEventData = new ScrollEventData(eventSystem);
}
if (currentGameObject != null && Mathf.Abs((currentScroll - lastScroll).x) >= 1 && Mathf.Abs(currentScroll.x) > float.Epsilon)
{
scrollEventData.Direction = (currentScroll - lastScroll).x >= 1 ? ScrollEventData.ScrollDirection.Right : ScrollEventData.ScrollDirection.Left;
GameObject scrollHandler = ExecuteEvents.GetEventHandler <IScrollToDirectHandler>(currentGameObject);
scrollEventData.selectedObject = scrollHandler;
ExecuteEvents.Execute(scrollHandler, scrollEventData, VRExecuteEvents.scrollToDirectHandler);
}
lastScroll = currentScroll;
}
else if (eligibleForScroll)
{
eligibleForScroll = false;
pointerData.scrollDelta = Vector2.zero;
}
}
//Highlights this button. Unity's default button wasn't really meant to be controlled through code so event handlers are necessary here.
//I would highly recommend not messing with this stuff unless you know what you're doing, if one event handler is wrong then the whole thing can break.
public void highlightThisElement(PointerEventData p)
{
ExecuteEvents.Execute(button.gameObject, p, ExecuteEvents.selectHandler);
active = true;
setParentMenuLable(label);
}
void PressButton(int i)
{
var eventSystem = EventSystem.current;
ExecuteEvents.Execute(_digitalButtons[i].gameObject, new BaseEventData(eventSystem), ExecuteEvents.submitHandler);
}
void GetButtonInput()
{
var pEventData = new PointerEventData(EventSystem.current);
ExecuteEvents.Execute(activeButton.gameObject, pEventData, ExecuteEvents.submitHandler);
}
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl)
{
if (!(rayOrigin.gameObject.activeSelf || draggedObject) || !proxy.active)
{
return;
}
var preProcessRaycastSource = m_Owner.preProcessRaycastSource;
if (preProcessRaycastSource != null)
{
preProcessRaycastSource(rayOrigin);
}
if (eventData == null)
{
eventData = new RayEventData(m_Owner.eventSystem);
}
hoveredObject = m_Owner.GetRayIntersection(this); // Check all currently running raycasters
eventData.node = node;
eventData.rayOrigin = rayOrigin;
eventData.pointerLength = m_Owner.GetPointerLength(eventData.rayOrigin);
var uiActions = (UIActions)input;
var select = uiActions.select;
if (isValid != null && !isValid(this))
{
var currentRaycast = eventData.pointerCurrentRaycast;
currentRaycast.gameObject = null;
eventData.pointerCurrentRaycast = currentRaycast;
hoveredObject = null;
m_Owner.HandlePointerExitAndEnter(eventData, null, true); // Send only exit events
if (select.wasJustReleased)
{
m_Owner.OnSelectReleased(this);
}
HideScrollFeedback();
return;
}
m_Owner.HandlePointerExitAndEnter(eventData, hoveredObject); // Send enter and exit events
var hasScrollHandler = false;
var hasInteractable = hasObject && HoveringInteractable(eventData, currentObject, out hasScrollHandler);
// Proceed only if pointer is interacting with something
if (!hasInteractable)
{
// If we have an object, the ray is blocked--input should not bleed through
if (hasObject && select.wasJustPressed)
{
consumeControl(select);
}
HideScrollFeedback();
if (select.wasJustReleased)
{
m_Owner.OnSelectReleased(this);
}
return;
}
// Send select pressed and released events
if (select.wasJustPressed)
{
m_Owner.OnSelectPressed(this);
consumeControl(select);
}
if (select.wasJustReleased)
{
m_Owner.OnSelectReleased(this);
}
// Send Drag Events
if (draggedObject != null)
{
ExecuteEvents.Execute(draggedObject, eventData, ExecuteEvents.dragHandler);
ExecuteEvents.Execute(draggedObject, eventData, ExecuteRayEvents.dragHandler);
}
// Send scroll events
if (currentObject && hasScrollHandler)
{
var verticalScroll = uiActions.verticalScroll;
var horizontalScroll = uiActions.horizontalScroll;
var verticalScrollValue = verticalScroll.value;
var horizontalScrollValue = horizontalScroll.value;
if (!Mathf.Approximately(verticalScrollValue, 0f) || !Mathf.Approximately(horizontalScrollValue, 0f))
{
consumeControl(verticalScroll);
consumeControl(horizontalScroll);
eventData.scrollDelta = new Vector2(horizontalScrollValue, verticalScrollValue);
ExecuteEvents.ExecuteHierarchy(currentObject, eventData, ExecuteEvents.scrollHandler);
}
if (m_ScrollFeedback.Count == 0)
{
ShowScrollFeedback();
}
}
}
/// <summary>
/// Calculate and process any mouse button state changes.
/// </summary>
protected 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);
}
m_InputPointerEvent = pointerEvent;
}
// PointerUp notification
if (data.ReleasedThisFrame())
{
ReleaseMouse(pointerEvent, currentOverGo);
}
}
public void UnHighlight(PointerEventData p)
{
ExecuteEvents.Execute(_button.gameObject, p, ExecuteEvents.deselectHandler);
_active = false;
}
void HandlePointerExitAndEnter(RayEventData eventData, GameObject newEnterTarget, bool exitOnly = false)
{
// Cache properties before executing base method, so we can complete additional ray events later
var cachedEventData = GetTempEventDataClone(eventData);
// This will modify the event data (new target will be set)
base.HandlePointerExitAndEnter(eventData, newEnterTarget);
var pointerEnter = cachedEventData.pointerEnter;
if (newEnterTarget == null || pointerEnter == null)
{
for (var i = 0; i < cachedEventData.hovered.Count; ++i)
{
var hovered = cachedEventData.hovered[i];
ExecuteEvents.Execute(hovered, eventData, ExecuteRayEvents.rayExitHandler);
if (rayExited != null)
{
rayExited(hovered, eventData);
}
}
if (newEnterTarget == null)
{
return;
}
}
if (!exitOnly)
{
// if we have not changed hover target
if (newEnterTarget && pointerEnter == newEnterTarget)
{
var transform = newEnterTarget.transform;
while (transform != null)
{
ExecuteEvents.Execute(transform.gameObject, cachedEventData, ExecuteRayEvents.rayHoverHandler);
if (rayHovering != null)
{
rayHovering(transform.gameObject, cachedEventData);
}
transform = transform.parent;
}
return;
}
}
var commonRoot = FindCommonRoot(pointerEnter, newEnterTarget);
// and we already an entered object from last time
if (pointerEnter != null)
{
// send exit handler call to all elements in the chain
// until we reach the new target, or null!
var transform = pointerEnter.transform;
while (transform != null)
{
// if we reach the common root break out!
if (commonRoot != null && commonRoot.transform == transform)
{
break;
}
ExecuteEvents.Execute(transform.gameObject, cachedEventData, ExecuteRayEvents.rayExitHandler);
if (rayExited != null)
{
rayExited(transform.gameObject, cachedEventData);
}
transform = transform.parent;
}
}
if (!exitOnly)
{
// now issue the enter call up to but not including the common root
cachedEventData.pointerEnter = newEnterTarget;
var transform = newEnterTarget.transform;
while (transform != null && transform.gameObject != commonRoot)
{
ExecuteEvents.Execute(transform.gameObject, cachedEventData, ExecuteRayEvents.rayEnterHandler);
if (rayEntered != null)
{
rayEntered(transform.gameObject, cachedEventData);
}
transform = transform.parent;
}
}
}
public void Highlight(PointerEventData p)
{
ExecuteEvents.Execute(_button.gameObject, p, ExecuteEvents.selectHandler);
_active = true;
//SetParentMenuLable(_label);
}
public void OnEndDrag(PointerEventData eventData)
{
OnEndDragEvent?.Invoke(eventData);
ExecuteEvents.Execute <IEndDragHandler>(ScrollGameObject, eventData, ExecuteEvents.endDragHandler);
}
public void ClickButtonFromOutside()
{
ExecuteEvents.Execute(button.gameObject, new BaseEventData(EventSystem.current), ExecuteEvents.submitHandler);
}
private void PressButton(Button button)
{
ExecuteEvents.Execute(button.gameObject, new BaseEventData(EventSystem.current), ExecuteEvents.submitHandler);
}
// Process is called by UI system to process events
public override void Process()
{
_singleton = this;
// send update events if there is a selected object - this is important for InputField to receive keyboard events
SendUpdateEventToSelectedObject();
// see if there is a UI element that is currently being looked at
PointerEventData lookData = GetLookPointerEventData();
currentLook = lookData.pointerCurrentRaycast.gameObject;
// deselect when look away
if (deselectWhenLookAway && currentLook == null)
{
ClearSelection();
}
// handle enter and exit events (highlight)
// using the function that is already defined in BaseInputModule
HandlePointerExitAndEnter(lookData, currentLook);
// update cursor
UpdateCursor(lookData);
if (!ignoreInputsWhenLookAway || ignoreInputsWhenLookAway && currentLook != null)
{
// button down handling
_buttonUsed = false;
if (Input.GetButtonDown(submitButtonName))
{
ClearSelection();
lookData.pressPosition = lookData.position;
lookData.pointerPressRaycast = lookData.pointerCurrentRaycast;
lookData.pointerPress = null;
if (currentLook != null)
{
currentPressed = currentLook;
GameObject newPressed = null;
if (mode == Mode.Pointer)
{
newPressed = ExecuteEvents.ExecuteHierarchy(currentPressed, lookData, ExecuteEvents.pointerDownHandler);
if (newPressed == null)
{
// some UI elements might only have click handler and not pointer down handler
newPressed = ExecuteEvents.ExecuteHierarchy(currentPressed, lookData, ExecuteEvents.pointerClickHandler);
if (newPressed != null)
{
currentPressed = newPressed;
}
}
else
{
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, lookData, ExecuteEvents.pointerClickHandler);
}
}
else if (mode == Mode.Submit)
{
newPressed = ExecuteEvents.ExecuteHierarchy(currentPressed, lookData, ExecuteEvents.submitHandler);
if (newPressed == null)
{
// try select handler instead
newPressed = ExecuteEvents.ExecuteHierarchy(currentPressed, lookData, ExecuteEvents.selectHandler);
}
}
if (newPressed != null)
{
lookData.pointerPress = newPressed;
currentPressed = newPressed;
Select(currentPressed);
_buttonUsed = true;
}
if (mode == Mode.Pointer)
{
if (useLookDrag)
{
bool useLookTest = true;
if (!useLookDragSlider && currentPressed.GetComponent <Slider>())
{
useLookTest = false;
}
else if (!useLookDragScrollbar && currentPressed.GetComponent <Scrollbar>())
{
useLookTest = false;
// the following is for scrollbars to work right
// apparently they go into an odd drag mode when pointerDownHandler is called
// a begin/end drag fixes that
if (ExecuteEvents.Execute(currentPressed, lookData, ExecuteEvents.beginDragHandler))
{
ExecuteEvents.Execute(currentPressed, lookData, ExecuteEvents.endDragHandler);
}
}
if (useLookTest)
{
ExecuteEvents.Execute(currentPressed, lookData, ExecuteEvents.beginDragHandler);
lookData.pointerDrag = currentPressed;
currentDragging = currentPressed;
}
}
else if (currentPressed.GetComponent <Scrollbar>())
{
// the following is for scrollbars to work right
// apparently they go into an odd drag mode when pointerDownHandler is called
// a begin/end drag fixes that
if (ExecuteEvents.Execute(currentPressed, lookData, ExecuteEvents.beginDragHandler))
{
ExecuteEvents.Execute(currentPressed, lookData, ExecuteEvents.endDragHandler);
}
}
}
}
}
}
// have to handle button up even if looking away
if (Input.GetButtonUp(submitButtonName))
{
if (currentDragging)
{
ExecuteEvents.Execute(currentDragging, lookData, ExecuteEvents.endDragHandler);
if (currentLook != null)
{
ExecuteEvents.ExecuteHierarchy(currentLook, lookData, ExecuteEvents.dropHandler);
}
lookData.pointerDrag = null;
currentDragging = null;
}
if (currentPressed)
{
ExecuteEvents.Execute(currentPressed, lookData, ExecuteEvents.pointerUpHandler);
lookData.rawPointerPress = null;
lookData.pointerPress = null;
currentPressed = null;
}
}
// drag handling
if (currentDragging != null)
{
ExecuteEvents.Execute(currentDragging, lookData, ExecuteEvents.dragHandler);
}
if (!ignoreInputsWhenLookAway || ignoreInputsWhenLookAway && currentLook != null)
{
// control axis handling
_controlAxisUsed = false;
if (eventSystem.currentSelectedGameObject && controlAxisName != null && controlAxisName != "")
{
float newVal = Input.GetAxis(controlAxisName);
if (newVal > 0.01f || newVal < -0.01f)
{
if (useSmoothAxis)
{
Slider sl = eventSystem.currentSelectedGameObject.GetComponent <Slider>();
if (sl != null)
{
float mult = sl.maxValue - sl.minValue;
sl.value += newVal * smoothAxisMultiplier * mult;
_controlAxisUsed = true;
}
else
{
Scrollbar sb = eventSystem.currentSelectedGameObject.GetComponent <Scrollbar>();
if (sb != null)
{
sb.value += newVal * smoothAxisMultiplier;
_controlAxisUsed = true;
}
}
}
else
{
_controlAxisUsed = true;
float time = Time.unscaledTime;
if (time > nextAxisActionTime)
{
nextAxisActionTime = time + 1f / steppedAxisStepsPerSecond;
AxisEventData axisData = GetAxisEventData(newVal, 0.0f, 0.0f);
if (!ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, axisData, ExecuteEvents.moveHandler))
{
_controlAxisUsed = false;
}
}
}
}
}
}
}
private void RouteEventToCurrentObject <T>(BaseEventData eventData, ExecuteEvents.EventFunction <T> eventFunction) where T : IEventSystemHandler
{
ExecuteEvents.Execute(gameObject, eventData, eventFunction);
}
private void ExecuteFocus()
{
ExecuteEvents.Execute(this.focusables[focus].gameObject, new BaseEventData(this.eventSystem), ExecuteEvents.submitHandler);
}
public static void EmitButtonClick(Button button)
{
ExecuteEvents.Execute(button.gameObject, new PointerEventData(EventSystem.current), ExecuteEvents.submitHandler);
}
public void ProcessInput(ActionMapInput input, Action <InputControl> consumeControl)
{
ExecuteUpdateOnSelectedObject();
if (m_EventCamera == null)
{
return;
}
m_RaycastSourcesCopy.Clear();
m_RaycastSourcesCopy.AddRange(m_RaycastSources.Values); // The sources dictionary can change during iteration, so cache it before iterating
//Process events for all different transforms in RayOrigins
foreach (var source in m_RaycastSourcesCopy)
{
if (!(source.rayOrigin.gameObject.activeSelf || source.draggedObject) || !source.proxy.active)
{
continue;
}
if (preProcessRaycastSource != null)
{
preProcessRaycastSource(source.rayOrigin);
}
if (source.eventData == null)
{
source.eventData = new RayEventData(base.eventSystem);
}
source.hoveredObject = GetRayIntersection(source); // Check all currently running raycasters
var eventData = source.eventData;
eventData.node = source.node;
eventData.rayOrigin = source.rayOrigin;
eventData.pointerLength = getPointerLength(eventData.rayOrigin);
if (!source.isValid(source))
{
continue;
}
HandlePointerExitAndEnter(eventData, source.hoveredObject); // Send enter and exit events
var hasScrollHandler = false;
source.actionMapInput.active = source.hasObject && ShouldActivateInput(eventData, source.currentObject, out hasScrollHandler);
// Proceed only if pointer is interacting with something
if (!source.actionMapInput.active)
{
continue;
}
// Send select pressed and released events
if (source.actionMapInput.select.wasJustPressed)
{
OnSelectPressed(source);
consumeControl(source.actionMapInput.select);
}
if (source.actionMapInput.select.wasJustReleased)
{
OnSelectReleased(source);
}
var draggedObject = source.draggedObject;
// Send Drag Events
if (source.draggedObject != null)
{
ExecuteEvents.Execute(draggedObject, eventData, ExecuteEvents.dragHandler);
ExecuteEvents.Execute(draggedObject, eventData, ExecuteRayEvents.dragHandler);
}
// Send scroll events
var scrollObject = source.hoveredObject;
if (!scrollObject)
{
scrollObject = source.draggedObject;
}
if (scrollObject && hasScrollHandler)
{
var actionMapInput = source.actionMapInput;
var verticalScroll = actionMapInput.verticalScroll;
var horizontalScroll = actionMapInput.horizontalScroll;
var verticalScrollValue = verticalScroll.value;
var horizontalScrollValue = horizontalScroll.value;
if (!Mathf.Approximately(verticalScrollValue, 0f) || !Mathf.Approximately(horizontalScrollValue, 0f))
{
consumeControl(verticalScroll);
consumeControl(horizontalScroll);
eventData.scrollDelta = new Vector2(horizontalScrollValue, verticalScrollValue);
ExecuteEvents.ExecuteHierarchy(scrollObject, eventData, ExecuteEvents.scrollHandler);
}
}
}
}
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);
}
}
}
protected void HandlePointerExitAndEnter(RayEventData eventData, GameObject newEnterTarget)
{
// Cache properties before executing base method, so we can complete additional ray events later
var cachedEventData = GetTempEventDataClone(eventData);
// This will modify the event data (new target will be set)
base.HandlePointerExitAndEnter(eventData, newEnterTarget);
if (newEnterTarget == null || cachedEventData.pointerEnter == null)
{
for (var i = 0; i < cachedEventData.hovered.Count; ++i)
{
ExecuteEvents.Execute(cachedEventData.hovered[i], eventData, ExecuteRayEvents.rayExitHandler);
rayExited(cachedEventData.hovered[i], eventData);
}
if (newEnterTarget == null)
{
return;
}
}
Transform t = null;
// if we have not changed hover target
if (cachedEventData.pointerEnter == newEnterTarget && newEnterTarget)
{
t = newEnterTarget.transform;
while (t != null)
{
ExecuteEvents.Execute(t.gameObject, cachedEventData, ExecuteRayEvents.rayHoverHandler);
t = t.parent;
}
return;
}
GameObject commonRoot = FindCommonRoot(cachedEventData.pointerEnter, newEnterTarget);
// and we already an entered object from last time
if (cachedEventData.pointerEnter != null)
{
// send exit handler call to all elements in the chain
// until we reach the new target, or null!
t = cachedEventData.pointerEnter.transform;
while (t != null)
{
// if we reach the common root break out!
if (commonRoot != null && commonRoot.transform == t)
{
break;
}
ExecuteEvents.Execute(t.gameObject, cachedEventData, ExecuteRayEvents.rayExitHandler);
rayExited(t.gameObject, cachedEventData);
t = t.parent;
}
}
// now issue the enter call up to but not including the common root
cachedEventData.pointerEnter = newEnterTarget;
t = newEnterTarget.transform;
while (t != null && t.gameObject != commonRoot)
{
ExecuteEvents.Execute(t.gameObject, cachedEventData, ExecuteRayEvents.rayEnterHandler);
rayEntered(t.gameObject, cachedEventData);
t = t.parent;
}
}
// Update is called once per frame
void Update()
{
//Raycast hitting landinggear lever
Ray ray = camera.ScreenPointToRay(Input.mousePosition);
RaycastHit2D hit = Physics2D.Raycast(ray.origin, ray.direction);
if (hit)
{
if (hit.collider.name == "LandingGear")
{
canHold = true;
}
}
//Moving the handle within boundaries
if (Input.GetMouseButton(0) && canHold)
{
Vector3 pos = Input.mousePosition;
if (canMoveY)
{
rectTransform.position = new Vector3(rectTransform.position.x, camera.ScreenToWorldPoint(pos).y + handleOffset, 79);
}
if (canMoveX)
{
rectTransform.position = new Vector3(camera.ScreenToWorldPoint(pos).x, rectTransform.position.y, 79);
}
if (canMoveX && canMoveY)
{
rectTransform.position = new Vector3(camera.ScreenToWorldPoint(pos).x, camera.ScreenToWorldPoint(pos).y + handleOffset, 79);
}
}
else if (Input.GetMouseButtonUp(0) && canHold)
{
canHold = false;
}
if (Input.GetMouseButtonDown(1))
{
Debug.Log(rectTransform.position);
}
if (rectTransform.position.y <= 289)
{
Debug.Log("Can move x");
canMoveX = true;
}
else
{
canMoveX = false;
}
//Checks if the landing gear lever is inside bounding box and blocks it from leaving
if (rectTransform.position.x >= 1471)
{
canMoveY = false;
}
else
{
canMoveY = true;
}
if (rectTransform.position.x < 1435.6f)
{
rectTransform.position = new Vector3(1440.5f, rectTransform.position.y, 79);
}
else if (rectTransform.position.x > 1676.6f)
{
rectTransform.position = new Vector3(1660.5f, rectTransform.position.y, 79);
}
if (rectTransform.position.y > 601)
{
rectTransform.position = new Vector3(rectTransform.position.x, 590, 79);
}
else if (rectTransform.position.y < 271)
{
rectTransform.position = new Vector3(rectTransform.position.x, 281, 79);
}
if (rectTransform.position.x > 1646)
{
ExecuteEvents.Execute <ICustomMessage>(indicatorHandler, null, (x, y) => x.landingGear(1));
ExecuteEvents.Execute <ICustomMessage>(cutSceneManager, null, (x, y) => x.landingGear(1));
}
}
internal static DriverResponse HandleDriverRequest(DriverRequest request)
{
var response = new DriverResponse {
method = request.method
};
var session = GetSession();
switch (request.method.ToLowerInvariant())
{
case "registereditor":
if (string.IsNullOrEmpty(session))
{
#if UNITY_EDITOR
SaveSession(request.session);
#endif
response.session = request.session;
}
else
{
response.session = session;
}
response.result = "unity";
break;
case "exist":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath,
gameObject => true.ToString());
break;
case "active":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath,
gameObject => gameObject.activeInHierarchy.ToString());
break;
case "onscreen":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath, gameObject => ScreenHelper.IsOnScreen(gameObject).ToString());
break;
case "graphicclickable":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath, gameObject => ScreenHelper.IsGraphicClickable(gameObject).ToString());
break;
case "physicclickable":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath, gameObject => ScreenHelper.IsPhysicClickable(gameObject).ToString());
break;
case "getcomponent":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath, gameObject =>
{
var component = gameObject.GetComponent(request.value);
return(component != null ? JsonUtility.ToJson(component) : "null");
});
break;
case "click":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath, gameObject =>
{
var pointer = new PointerEventData(EventSystem.current);
ExecuteEvents.Execute(gameObject, pointer, ExecuteEvents.pointerClickHandler);
return(ErrorMessages.SuccessResult);
});
break;
case "isrendering":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath,
go =>
{
var renderer = go.GetComponent <Renderer>();
if (renderer != null)
{
return(renderer.isVisible.ToString());
}
return(false.ToString());
});
break;
case "count":
response.result = MainThreadHelper.ExecuteGameObjectsEmulation(request.upath, goList => goList.Count.ToString());
break;
case "deleteplayerpref":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() =>
{
PlayerPrefs.DeleteKey(request.key);
PlayerPrefs.Save();
});
break;
case "deleteallprefs":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() =>
{
PlayerPrefs.DeleteAll();
PlayerPrefs.Save();
});
break;
case "getfloatplayerpref":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() => PlayerPrefs.GetFloat(request.key).ToString(CultureInfo.InvariantCulture));
break;
case "getintplayerpref":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() => PlayerPrefs.GetInt(request.key).ToString());
break;
case "getstringplayerpref":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() => PlayerPrefs.GetString(request.key));
break;
case "setfloatplayerpref":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() =>
{
var result = ErrorMessages.SuccessResult;
try
{
PlayerPrefs.SetFloat(request.key, float.Parse(request.value));
PlayerPrefs.Save();
}
catch (Exception e)
{
result = e.ToString();
}
return(result);
});
break;
case "setintplayerpref":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() =>
{
var result = ErrorMessages.SuccessResult;
try
{
PlayerPrefs.SetInt(request.key, int.Parse(request.value));
PlayerPrefs.Save();
}
catch (Exception e)
{
result = e.ToString();
}
return(result);
});
break;
case "setstringplayerpref":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() =>
{
var result = ErrorMessages.SuccessResult;
try
{
PlayerPrefs.SetFloat(request.key, float.Parse(request.value));
PlayerPrefs.Save();
}
catch (Exception e)
{
result = e.ToString();
}
return(result);
});
break;
case "playerprefhaskey":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() =>
{
string result;
try
{
result = PlayerPrefs.HasKey(request.key).ToString();
}
catch (Exception e)
{
result = e.ToString();
}
return(result);
});
break;
case "getcoordinates":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath, gameObject =>
{
var position = ScreenHelper.GetPositionOnScreen(gameObject, Camera.main);
var coordinates = new ScreenCoordinates {
X = position.x, Y = position.y
};
return(JsonUtility.ToJson(coordinates));
});
break;
case "swipe":
var swipeDirection = Vector2.zero;
switch (request.value)
{
case "up":
swipeDirection = Vector2.up;
break;
case "down":
swipeDirection = Vector2.down;
break;
case "left":
swipeDirection = Vector2.left;
break;
case "right":
swipeDirection = Vector2.right;
break;
}
swipeDirection *= 100;
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath, gameObject => {
var pointer = new PointerEventData(EventSystem.current);
gameObject.GetComponent <MonoBehaviour>().StartCoroutine(DragCoroutine(gameObject, pointer, (Vector2)ScreenHelper.GetPositionOnScreen(gameObject, Camera.main) + swipeDirection * 2));
return(ErrorMessages.SuccessResult);
});
break;
case "dragto":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath, gameObject => {
var screenCoordinates = new ScreenCoordinates();
JsonUtility.FromJsonOverwrite(request.value, screenCoordinates);
var pointer = new PointerEventData(EventSystem.current);
gameObject.GetComponent <MonoBehaviour>().StartCoroutine(DragCoroutine(gameObject, pointer,
new Vector2 {
x = screenCoordinates.X, y = screenCoordinates.Y
}));
return("OK");
});
break;
case "sendkeys":
response.result = MainThreadHelper.ExecuteGameObjectEmulation(request.upath, gameObject =>
{
var input = gameObject.GetComponent <InputField>();
if (input != null)
{
input.text = request.value;
}
else
{
var tmpInput = gameObject.GetComponent <TMP_InputField>();
if (tmpInput != null)
{
tmpInput.text = request.value;
}
else
{
return("input not found");
}
}
return(ErrorMessages.SuccessResult);
});
break;
case "startplaymode":
#if UNITY_EDITOR
EditorApplication.update += StartPlayMode;
response.result = ErrorMessages.SuccessResult;
#else
response.result = ErrorMessages.MethodIsNotSupported;
#endif
break;
case "stopplaymode":
#if UNITY_EDITOR
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() =>
{
//EditorApplication.UnlockReloadAssemblies();
EditorApplication.isPlaying = false;
});
#else
response.result = ErrorMessages.MethodIsNotSupported;
#endif
break;
case "ping":
response.result = "pong";
break;
case "takescreenshot":
var path = request.value;
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() => { TakeScreenshot(path); });
break;
case "isplaymode":
response.result = MainThreadHelper.InvokeOnMainThreadAndWait(() => Application.isPlaying.ToString());
break;
case "custom":
response.result = CustomDriverHandler.Process(request.key, request.value);
break;
default:
response.result = "Unknown method " + request.method + ".";
break;
}
return(response);
}
//默认点击
public void AutoClick()
{
ExecuteEvents.Execute <IPointerClickHandler>(nBt.gameObject, new PointerEventData(EventSystem.current), ExecuteEvents.pointerClickHandler);
ExecuteEvents.Execute <ISubmitHandler>(nBt.gameObject, new PointerEventData(EventSystem.current), ExecuteEvents.submitHandler);
}
// reimplementation of VRInputModule's HandlePointerExitAndEnter
// only functional change should be that we target the off-hand controller for haptics
private void HandlePointerExitAndEnter(VRInputModule vrInputModule, PointerEventData eventData, GameObject newEnterTarget)
{
if (newEnterTarget == null || eventData.pointerEnter == null)
{
foreach (var hovered in eventData.hovered)
{
ExecuteEvents.Execute(hovered, eventData, ExecuteEvents.pointerExitHandler);
}
eventData.hovered.Clear();
if (newEnterTarget == null)
{
eventData.pointerEnter = null;
return;
}
}
// at this point, newEnterTarget cannot be null
if (eventData.pointerEnter == newEnterTarget)
{
return;
}
GameObject commonRoot = null;
Transform t = null;
if (eventData.pointerEnter != null)
{
// reimplementation of BaseInputModule.FindCommonRoot
Transform t1 = eventData.pointerEnter.transform;
bool found = false;
while (t1 != null)
{
Transform t2 = newEnterTarget.transform;
while (t2 != null)
{
if (t1 == t2)
{
commonRoot = t1.gameObject;
found = true;
break;
}
t2 = t2.parent;
}
if (found)
{
break;
}
else
{
t1 = t1.parent;
}
}
t = eventData.pointerEnter.transform;
while (t != null && commonRoot?.transform != t)
{
ExecuteEvents.Execute(t.gameObject, eventData, ExecuteEvents.pointerExitHandler);
eventData.hovered.Remove(t.gameObject);
t = t.parent;
}
}
if (!vrInputModule.userInteractionEnabled)
{
return;
}
bool hasTriggeredHapticPulse = false;
eventData.pointerEnter = newEnterTarget;
t = newEnterTarget.transform;
while (t != null && t.gameObject != commonRoot)
{
_componentsList.Clear();
t.gameObject.GetComponents(_componentsList);
if (!hasTriggeredHapticPulse)
{
foreach (var component in _componentsList)
{
Selectable selectable = component as Selectable;
Interactable interactable = component as Interactable;
if ((selectable != null && selectable.isActiveAndEnabled && selectable.interactable) ||
(interactable != null && interactable.isActiveAndEnabled && interactable.interactable))
{
VRPlatformHelperAccessor(ref vrInputModule).TriggerHapticPulse(_laserPointer.OffHandController.node, 0.25f);
hasTriggeredHapticPulse = true;
break;
}
}
}
ExecuteEvents.Execute(t.gameObject, eventData, ExecuteEvents.pointerEnterHandler);
eventData.hovered.Add(t.gameObject);
t = t.parent;
}
}
public virtual void ProcessPressed(object sender, PointerEventArgs pointerEventArgs)
{
#if UNITY_5_6_OR_NEWER
uiSampler.Begin();
#endif
var pointers = pointerEventArgs.Pointers;
var count = pointers.Count;
for (var i = 0; i < count; i++)
{
var pointer = pointers[i];
var over = pointer.GetOverData();
// Don't update the pointer if it is not over an UI element
if (over.Type != HitData.HitType.UI)
{
continue;
}
PointerEventData data;
GetPointerData(pointer.Id, out data, true);
var target = over.Target;
var currentOverGo = target == null ? null : target.gameObject;
data.eligibleForClick = true;
data.delta = Vector2.zero;
data.dragging = false;
data.useDragThreshold = true;
data.position = pointer.Position;
data.pressPosition = pointer.Position;
data.pointerPressRaycast = data.pointerCurrentRaycast;
DeselectIfSelectionChanged(currentOverGo, data);
if (data.pointerEnter != currentOverGo)
{
// send a pointer enter to the touched element if it isn't the one to select...
input.HandlePointerExitAndEnter(data, currentOverGo);
data.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, data, 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 == data.lastPress) // ?
{
var diffTime = time - data.clickTime;
if (diffTime < 0.3f)
{
++data.clickCount;
}
else
{
data.clickCount = 1;
}
data.clickTime = time;
}
else
{
data.clickCount = 1;
}
data.pointerPress = newPressed;
data.rawPointerPress = currentOverGo;
data.clickTime = time;
// Save the drag handler as well
data.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo);
if (data.pointerDrag != null)
{
ExecuteEvents.Execute(data.pointerDrag, data, ExecuteEvents.initializePotentialDrag);
}
}
#if UNITY_5_6_OR_NEWER
uiSampler.End();
#endif
}
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;
}
}
override public void releaseAnimation(GameObject button)
{
var pointer = new PointerEventData(EventSystem.current);
ExecuteEvents.Execute(button, pointer, ExecuteEvents.pointerUpHandler);
}
void ProcessMousePress( PointerInputModule.MouseButtonEventData data )
{
var buttonData = data.buttonData;
var 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;
DeselectIfSelectionChanged( gameObject, buttonData );
var gameObject2 = ExecuteEvents.ExecuteHierarchy<IPointerDownHandler>( gameObject, buttonData, ExecuteEvents.pointerDownHandler );
if (gameObject2 == null)
{
gameObject2 = ExecuteEvents.GetEventHandler<IPointerClickHandler>( gameObject );
}
var unscaledTime = Time.unscaledTime;
if (gameObject2 == buttonData.lastPress)
{
var num = unscaledTime - buttonData.clickTime;
if (num < 0.3f)
{
buttonData.clickCount++;
}
else
{
buttonData.clickCount = 1;
}
buttonData.clickTime = unscaledTime;
}
else
{
buttonData.clickCount = 1;
}
buttonData.pointerPress = gameObject2;
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 );
var eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>( gameObject );
if (buttonData.pointerPress == eventHandler && buttonData.eligibleForClick)
{
ExecuteEvents.Execute<IPointerClickHandler>( buttonData.pointerPress, buttonData, ExecuteEvents.pointerClickHandler );
}
else
{
if (buttonData.pointerDrag != null)
{
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)
{
HandlePointerExitAndEnter( buttonData, null );
HandlePointerExitAndEnter( buttonData, gameObject );
}
}
}