protected virtual void ProcessDrag(PointerEventData pointerEvent) { if (!pointerEvent.IsPointerMoving() || Cursor.lockState == CursorLockMode.Locked || pointerEvent.pointerDrag == null) { return; } if (!pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } // Drag notification if (pointerEvent.dragging) { // Before doing drag we should cancel any pointer down state // And clear selection! if (pointerEvent.pointerPress != pointerEvent.pointerDrag) { ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; } ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } }
private void ProcessDrag() { bool moving = pointerEventData.IsPointerMoving(); if (moving && pointerEventData.pointerDrag != null && !pointerEventData.dragging && ShouldStartDrag(pointerEventData.pressPosition, pointerEventData.position, eventSystem.pixelDragThreshold, pointerEventData.useDragThreshold)) { ExecuteEvents.Execute(pointerEventData.pointerDrag, pointerEventData, ExecuteEvents.beginDragHandler); pointerEventData.dragging = true; } // Drag notification if (pointerEventData.dragging && moving && pointerEventData.pointerDrag != null) { // Before doing drag we should cancel any pointer down state // And clear selection! if (pointerEventData.pointerPress != pointerEventData.pointerDrag) { ExecuteEvents.Execute(pointerEventData.pointerPress, pointerEventData, ExecuteEvents.pointerUpHandler); pointerEventData.eligibleForClick = false; pointerEventData.pointerPress = null; pointerEventData.rawPointerPress = null; } ExecuteEvents.Execute(pointerEventData.pointerDrag, pointerEventData, ExecuteEvents.dragHandler); } }
protected virtual void ProcessDrag(PointerEventData pointerEvent) { /* used in StandaloneInputModule.ProcessToucheEvents() and StandaloneInputModule.ProcessMouseEvent(int id) * call OnBeginDrag * call OnPointerUp, if for some reason pointerPress != pointerDrag * call OnDrag */ if (pointerEvent.IsPointerMoving() && Cursor.lockState != CursorLockMode.Locked && !(pointerEvent.pointerDrag == null)) { if (!pointerEvent.dragging && PointerInputModule.ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)) { ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } if (pointerEvent.dragging) { if (pointerEvent.pointerPress != pointerEvent.pointerDrag) { ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; } ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } } }
/// <summary> /// The purpose of this function is to allow us to switch between using the standard IsPointerMoving /// method for mouse driven pointers, but to always return true when it's a ray based pointer. /// All real-world ray-based input devices are always moving so for simplicity we just return true /// for them. /// /// If PointerEventData.IsPointerMoving was virtual we could just override that in /// OVRRayPointerEventData. /// </summary> /// <param name="pointerEvent"></param> /// <returns></returns> static bool IsPointerMoving(PointerEventData pointerEvent) { if (pointerEvent.IsVRPointer()) return true: else return pointerEvent.IsPointerMoving(): }
private static bool UseMouse(bool pressed, bool released, PointerEventData pointerData) { if (pressed || released || pointerData.IsPointerMoving() || pointerData.IsScrolling()) { return(true); } return(false); }
/// <summary> /// The purpose of this function is to allow us to switch between using the standard IsPointerMoving /// method for mouse driven pointers, but to always return true when it's a ray based pointer. /// All real-world ray-based input devices are always moving so for simplicity we just return true /// for them. /// /// If PointerEventData.IsPointerMoving was virtual we could just override that in /// OVRRayPointerEventData. /// </summary> /// <param name="pointerEvent"></param> /// <returns></returns> static bool IsPointerMoving(PointerEventData pointerEvent) { if (pointerEvent.IsVRPointer()) { return(true); } else { return(pointerEvent.IsPointerMoving()); } }
static bool IsPointerMoving(PointerEventData pointerEvent) { if (pointerEvent.IsF3dSpacePointer()) { return(true); } else { } return(pointerEvent.IsPointerMoving()); }
static public int IsPointerMoving(IntPtr l) { try { UnityEngine.EventSystems.PointerEventData self = (UnityEngine.EventSystems.PointerEventData)checkSelf(l); var ret = self.IsPointerMoving(); pushValue(l, ret); return(1); } catch (Exception e) { LuaDLL.luaL_error(l, e.ToString()); return(0); } }
/// <summary> /// The purpose of this function is to allow us to switch between using the standard IsPointerMoving /// method for mouse driven pointers, but to always return true when it's a ray based pointer. /// All real-world ray-based input devices are always moving so for simplicity we just return true /// for them. /// /// If PointerEventData.IsPointerMoving was virtual we could just override that in /// OVRRayPointerEventData. /// </summary> /// <param name="pointerEvent"></param> /// <returns></returns> static bool IsPointerMoving(PointerEventData pointerEvent) { OVRRayPointerEventData rayPointerEventData = pointerEvent as OVRRayPointerEventData; if (rayPointerEventData != null) { return(true); } else { return(pointerEvent.IsPointerMoving()); } }
static public int IsPointerMoving(IntPtr l) { try { UnityEngine.EventSystems.PointerEventData self = (UnityEngine.EventSystems.PointerEventData)checkSelf(l); var ret = self.IsPointerMoving(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
static int QPYX_IsPointerMoving_YXQP(IntPtr L_YXQP) { try { ToLua.CheckArgsCount(L_YXQP, 1); UnityEngine.EventSystems.PointerEventData QPYX_obj_YXQP = (UnityEngine.EventSystems.PointerEventData)ToLua.CheckObject <UnityEngine.EventSystems.PointerEventData>(L_YXQP, 1); bool QPYX_o_YXQP = QPYX_obj_YXQP.IsPointerMoving(); LuaDLL.lua_pushboolean(L_YXQP, QPYX_o_YXQP); return(1); } catch (Exception e_YXQP) { return(LuaDLL.toluaL_exception(L_YXQP, e_YXQP)); } }
static int IsPointerMoving(IntPtr L) { try { ToLua.CheckArgsCount(L, 1); UnityEngine.EventSystems.PointerEventData obj = (UnityEngine.EventSystems.PointerEventData)ToLua.CheckObject(L, 1, typeof(UnityEngine.EventSystems.PointerEventData)); bool o = obj.IsPointerMoving(); LuaDLL.lua_pushboolean(L, o); return(1); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
// Token: 0x06000237 RID: 567 RVA: 0x0001E49C File Offset: 0x0001C69C protected virtual void ProcessDrag(PointerEventData pointerEvent) { bool flag = pointerEvent.IsPointerMoving(); if (flag && pointerEvent.pointerDrag != null && !pointerEvent.dragging && CusPointerInputModule.ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)) { ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } if (pointerEvent.dragging && flag && pointerEvent.pointerDrag != null) { if (pointerEvent.pointerPress != pointerEvent.pointerDrag) { ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; } ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } }
/// <summary> /// /// <para> /// Process the drag for the current frame with the given pointer event. /// </para> /// /// </summary> /// <param name="pointerEvent"/> protected virtual void ProcessDrag(PointerEventData pointerEvent) { bool flag = pointerEvent.IsPointerMoving(); if (flag && (Object)pointerEvent.pointerDrag != (Object)null && (!pointerEvent.dragging && PointerInputModule.ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)this.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))) { ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, (BaseEventData)pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } if (!pointerEvent.dragging || !flag || !((Object)pointerEvent.pointerDrag != (Object)null)) { return; } if ((Object)pointerEvent.pointerPress != (Object)pointerEvent.pointerDrag) { ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.pointerPress, (BaseEventData)pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = (GameObject)null; pointerEvent.rawPointerPress = (GameObject)null; } ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, (BaseEventData)pointerEvent, ExecuteEvents.dragHandler); }
/// <summary> /// <para>Process the drag for the current frame with the given pointer event.</para> /// </summary> /// <param name="pointerEvent"></param> protected virtual void ProcessDrag(PointerEventData pointerEvent) { if ((pointerEvent.IsPointerMoving() && (Cursor.lockState != CursorLockMode.Locked)) && (pointerEvent.pointerDrag != null)) { if (!pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)) { ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } if (pointerEvent.dragging) { if (pointerEvent.pointerPress != pointerEvent.pointerDrag) { ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; } ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } } }
protected virtual void ProcessDrag(PointerEventData pointerEvent) { // DOC-HINT :::::: multi event system support // check if the event data does not belong to the eventsystem associated with the module if (!this.CompareEventSystemID(pointerEvent)) { // exit method execution return; } bool moving = pointerEvent.IsPointerMoving(); if (moving && pointerEvent.pointerDrag != null && !pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } // Drag notification if (pointerEvent.dragging && moving && pointerEvent.pointerDrag != null) { // Before doing drag we should cancel any pointer down state // And clear selection! if (pointerEvent.pointerPress != pointerEvent.pointerDrag) { ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; } ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } }
protected virtual void ProcessDrag(PointerEventData pointerEvent) { bool flag = pointerEvent.IsPointerMoving(); if ((flag && (pointerEvent.pointerDrag != null)) && (!pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float) base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))) { ExecuteEvents.Execute<IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } if ((pointerEvent.dragging && flag) && (pointerEvent.pointerDrag != null)) { if (pointerEvent.pointerPress != pointerEvent.pointerDrag) { ExecuteEvents.Execute<IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; } ExecuteEvents.Execute<IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } }
private static bool UseMouse(bool pressed, bool released, PointerEventData pointerData) { if(pressed || released || pointerData.IsPointerMoving() || pointerData.IsScrolling()) return true; return false; }
/// <summary> /// Moves injected pointer in UI. /// </summary> /// <param name="pointerEvent"> The pointer data. </param> protected void movePointer(PointerEventData pointerEvent) { var targetGO = pointerEvent.pointerCurrentRaycast.gameObject; HandlePointerExitAndEnter(pointerEvent, targetGO); bool moving = pointerEvent.IsPointerMoving(); if (moving && pointerEvent.pointerDrag != null && !pointerEvent.dragging && shouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } // Drag notification if (pointerEvent.dragging && moving && pointerEvent.pointerDrag != null) { // Before doing drag we should cancel any pointer down state // And clear selection! if (pointerEvent.pointerPress != pointerEvent.pointerDrag) { ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; } ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } }
// walk up the tree till a common root between the last entered and the current entered is found // send exit events up to (including) the common root. Then send enter events up to // (including) the common root. // Send move events before exit, after enter, and on hovered objects when pointer data has changed. 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) { var hoveredCount = currentPointerData.hovered.Count; for (var i = 0; i < hoveredCount; ++i) { ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerMoveHandler); ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerExitHandler); } currentPointerData.hovered.Clear(); if (newEnterTarget == null) { currentPointerData.pointerEnter = null; return; } } // if we have not changed hover target if (currentPointerData.pointerEnter == newEnterTarget && newEnterTarget) { if (currentPointerData.IsPointerMoving()) { var hoveredCount = currentPointerData.hovered.Count; for (var i = 0; i < hoveredCount; ++i) { ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerMoveHandler); } } 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) { ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerMoveHandler); ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerExitHandler); currentPointerData.hovered.Remove(t.gameObject); // if we reach the common root break out! if (commonRoot != null && commonRoot.transform == t) { break; } 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) { ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerEnterHandler); ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerMoveHandler); currentPointerData.hovered.Add(t.gameObject); if (commonRoot != null && commonRoot.transform == t) { break; } t = t.parent; } } }
/// <summary> /// /// <para> /// Process the drag for the current frame with the given pointer event. /// </para> /// /// </summary> /// <param name="pointerEvent"/> protected virtual void ProcessDrag(PointerEventData pointerEvent) { bool flag = pointerEvent.IsPointerMoving(); if (flag && (Object) pointerEvent.pointerDrag != (Object) null && (!pointerEvent.dragging && PointerInputModule.ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float) this.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))) { ExecuteEvents.Execute<IBeginDragHandler>(pointerEvent.pointerDrag, (BaseEventData) pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } if (!pointerEvent.dragging || !flag || !((Object) pointerEvent.pointerDrag != (Object) null)) return; if ((Object) pointerEvent.pointerPress != (Object) pointerEvent.pointerDrag) { ExecuteEvents.Execute<IPointerUpHandler>(pointerEvent.pointerPress, (BaseEventData) pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = (GameObject) null; pointerEvent.rawPointerPress = (GameObject) null; } ExecuteEvents.Execute<IDragHandler>(pointerEvent.pointerDrag, (BaseEventData) pointerEvent, ExecuteEvents.dragHandler); }
private static bool IsPointerMoving(PointerEventData pointerEvent) { return(pointerEvent.IsVRPointer() || pointerEvent.IsPointerMoving()); }
protected virtual void ProcessDrag(PointerEventData pointerEvent) { bool moving = pointerEvent.IsPointerMoving(); if (moving && pointerEvent.pointerDrag != null && !pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)) { ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } // Drag notification if (pointerEvent.dragging && moving && pointerEvent.pointerDrag != null) { // Before doing drag we should cancel any pointer down state // And clear selection! if (pointerEvent.pointerPress != pointerEvent.pointerDrag) { ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); pointerEvent.eligibleForClick = false; pointerEvent.pointerPress = null; pointerEvent.rawPointerPress = null; } ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } }
protected override void ProcessDrag(PointerEventData pointerEvent) { /* used in StandaloneInputModule.ProcessToucheEvents() and StandaloneInputModule.ProcessMouseEvent(int id) * call OnBeginDrag * call OnPointerUp, if for some reason pointerPress != pointerDrag * call OnDrag * * pointerDrag could be DragHandler, HorizontalDragHandler, or VerticalDragHandler */ if (pointerEvent.IsPointerMoving() && Cursor.lockState != CursorLockMode.Locked && !(pointerEvent.pointerDrag == null)) { if (!pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, (float)base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold)) { ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); pointerEvent.dragging = true; } if (pointerEvent.dragging) { // if (pointerEvent.pointerPress != pointerEvent.pointerDrag) // { // ExecuteEvents.Execute<IPointerUpHandler>(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); // pointerEvent.pointerPress = null; // pointerEvent.eligibleForClick = false; // pointerEvent.rawPointerPress = null; // } print("pointerDrag is " + pointerEvent.pointerDrag.gameObject.name); if (!ExecuteEvents.CanHandleEvent <IHorizontalDragHandler>(pointerEvent.pointerDrag) && !ExecuteEvents.CanHandleEvent <IVerticalDragHandler>(pointerEvent.pointerDrag) && ExecuteEvents.CanHandleEvent <IDragHandler>(pointerEvent.pointerDrag)) { ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } else { float thresh = (float)base.eventSystem.pixelDragThreshold; if (pointerEvent.delta.sqrMagnitude > (thresh * thresh)) { if (Mathf.Abs(Vector2.Dot(Vector2.right, pointerEvent.delta.normalized)) > Mathf.Cos(45f * Mathf.Deg2Rad)) { if (ExecuteEvents.CanHandleEvent <IHorizontalDragHandler>(pointerEvent.pointerDrag)) { ExecuteEvents.Execute <IHorizontalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.horizontalDragHandler); } else { GameObject prevPointerDrag = pointerEvent.pointerDrag; pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler <IHorizontalDragHandler>(pointerEvent.pointerCurrentRaycast.gameObject); if (pointerEvent.pointerDrag != null) { // print("switch to h"); ExecuteEvents.Execute <IEndDragHandler>(prevPointerDrag, pointerEvent, ExecuteEvents.endDragHandler); ExecuteEvents.Execute <IInitializePotentialDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag); ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); ExecuteEvents.Execute <IHorizontalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.horizontalDragHandler); } else { // print("no handler for h"); pointerEvent.pointerDrag = prevPointerDrag; ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } } } else { if (ExecuteEvents.CanHandleEvent <IVerticalDragHandler>(pointerEvent.pointerDrag)) { ExecuteEvents.Execute <IVerticalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.verticalDragHandler); } else { GameObject prevPointerDrag = pointerEvent.pointerDrag; pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler <IVerticalDragHandler>(pointerEvent.pointerCurrentRaycast.gameObject); if (pointerEvent.pointerDrag != null) { // print("switch to v"); ExecuteEvents.Execute <IEndDragHandler>(prevPointerDrag, pointerEvent, ExecuteEvents.endDragHandler); ExecuteEvents.Execute <IInitializePotentialDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag); ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler); ExecuteEvents.Execute <IVerticalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.verticalDragHandler); } else { // print("no handler for v"); pointerEvent.pointerDrag = prevPointerDrag; ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } } } } else { // print("under thresh"); if (Mathf.Abs(Vector2.Dot(Vector2.right, pointerEvent.delta.normalized)) > Mathf.Cos(45f * Mathf.Deg2Rad)) { if (ExecuteEvents.CanHandleEvent <IHorizontalDragHandler>(pointerEvent.pointerDrag)) { ExecuteEvents.Execute <IHorizontalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.horizontalDragHandler); } else { ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } } else { if (ExecuteEvents.CanHandleEvent <IVerticalDragHandler>(pointerEvent.pointerDrag)) { ExecuteEvents.Execute <IVerticalDragHandler>(pointerEvent.pointerDrag, pointerEvent, CustomEvents.verticalDragHandler); } else { ExecuteEvents.Execute <IDragHandler>(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler); } } } } prevDelta = pointerEvent.delta; } } }
/// <summary> /// The purpose of this function is to allow us to switch between using the standard IsPointerMoving /// method for mouse driven pointers, but to always return true when it's a ray based pointer. /// All real-world ray-based input devices are always moving so for simplicity we just return true /// for them. /// /// If PointerEventData.IsPointerMoving was virtual we could just override that in /// OVRRayPointerEventData. /// </summary> /// <param name="pointerEvent"></param> /// <returns></returns> static bool IsPointerMoving(PointerEventData pointerEvent) { OVRRayPointerEventData rayPointerEventData = pointerEvent as OVRRayPointerEventData; if (rayPointerEventData != null) return true; else return pointerEvent.IsPointerMoving(); }
static bool UseMouse( bool pressed, bool released, PointerEventData pointerData ) { return pressed || released || pointerData.IsPointerMoving() || pointerData.IsScrolling(); }
bool UseMouse( bool pressed, bool released, PointerEventData pointerData ) { if (currentInputSource == InputSource.Mouse) { return true; } if (pressed || released || pointerData.IsPointerMoving() || pointerData.IsScrolling()) { currentInputSource = InputSource.Mouse; base.eventSystem.SetSelectedGameObject( null, pointerData ); } return currentInputSource == InputSource.Mouse; }